@bongos/core 1.24.19 → 1.24.21

package/package-lock.json

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

package/package.json

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

@@ -10999,5 +10999,21 @@
       "id": "1005030",
       "text": "A mockup of the Builders leaderboard now shows the circuit-trace divider from the owner's Studio idea between the column headings and the table. The live page is unchanged."
     }
+  ],
+  "1.24.20": [
+    {
+      "id": "1005031",
+      "text": "The Studio now shows what a picture will cost and asks before it starts, shows the final cost, and writes its answers in readable headings and lists."
+    },
+    {
+      "id": "1005032",
+      "text": "The Builders page now has the circuit-trace divider from the owner's Studio idea between the column headings and the first row, in light and dark and on phones."
+    }
+  ],
+  "1.24.21": [
+    {
+      "id": "1005013",
+      "text": "Every card in the city now says what it is. Under each question sits a short plain explanation: what kind of thing it is, which goal, task, person or module it belongs to, and what answering does. A Review card used to show a"
+    }
   ]
 }

package/src/bongos/module-rechecks.js

@@ -77,6 +77,9 @@ function moduleRecheckMatter(r, mayRerun) {
     proposer: null,
     tally: null,
     href: '/modules',
+    context: failed
+      ? `${r.module_key} is a module (an add-on to this project). Version ${r.version} failed its automatic security check, so it is held back until someone runs the check again.`
+      : `${r.module_key} is a module (an add-on to this project). Version ${r.version} is being checked again for safety; nothing is needed unless the check fails.`,
     // "<key>@<version>": the reassess route's two path parts (task 1004566)
     ref: { type: 'module_version', id: `${r.module_key}@${r.version}` },
     // the one act a governor takes on it, under the reassess route's own atom,

package/src/bongos/routes/core-update.js

@@ -143,6 +143,8 @@ function coreUpdateDocketMatters(update) {
     tally: null,
     href: '/settings#software-update',
     ref: { type: 'core_version', id: String(update.latest) },
+    question: `Update Bongos to ${update.latest}?`,
+    context: `Bongos is the software this project runs on. This project runs ${update.running}; ${update.latest} is out. Taking it moves the project to the new version on its next restart.`,
   }];
 }
 // The running core, or null when it cannot be named. Read lazily and fail-soft,

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

@@ -0,0 +1,139 @@
+// tests/city_card_context.mjs — EVERY CITY CARD SAYS WHAT IT IS (task 1005013).
+//
+// The owner, 2026-10-29: the cards "exist without context". A Review card showed a
+// done-when criterion's raw wording with no question; a security card "Security
+// report: <title>". What this pins:
+//   * the docket passes a matter's own `context` and `question` through, bounded,
+//     and gives every source the design names a plain sentence of its own when a
+//     matter brought none — no card is ever only a bare title;
+//   * every source's mapper writes context naming what it belongs to (the goal,
+//     the task, the person, the module) — the Review card names its goal, its
+//     shipped tasks and what the sign-off closes, and asks a real question;
+//   * the hall carries both to the card, and the one card drawing (drawAsk: deck,
+//     street, interior, city) shows the context under the question.
+//
+// Run:  node --test tests/city_card_context.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const docket = require('../modules/government/docket.js');
+const lifecycleDocket = require('../modules/lifecycle/governor-docket.js');
+const ideasDocket = require('../modules/ideas/governor-docket.js');
+const reportsRoute = require('../modules/security/routes/reports.js');
+const accessRoute = require('../modules/onboarding/routes/access-requests.js');
+const coreUpdate = require('../src/bongos/routes/core-update.js');
+const moduleRechecks = require('../src/bongos/module-rechecks.js');
+const treasury = require('../modules/government/treasury.js');
+const living = require('../modules/hall-ui/public/gov-living.js');
+const deck = require('../modules/hall-ui/public/street-deck.js');
+
+const at = { source: 'criteria_uat', building: 'review' };
+
+test('every source the design names has its own plain sentence, used when a matter brings none', () => {
+  for (const s of docket.EXPECTED_SOURCES) {
+    const words = docket.SOURCE_CONTEXT[s.source];
+    assert.ok(typeof words === 'string' && words.length > 40, `${s.source} has a sentence`);
+    assert.equal(docket.normalizeMatter({ id: 1, title: 't' }, { source: s.source, building: s.building }).context, words);
+  }
+});
+
+test('a matter\'s own context and question win, bounded and on one line; junk is dropped', () => {
+  const m = docket.normalizeMatter({ id: 1, title: 't', context: '  Its   own\nwords.  ', question: ' Does it work? ' }, at);
+  assert.equal(m.context, 'Its own words.');
+  assert.equal(m.question, 'Does it work?');
+  const long = docket.normalizeMatter({ id: 1, title: 't', context: 'word '.repeat(400), question: 'q '.repeat(200) }, at);
+  assert.ok(long.context.length <= 600 && long.context.endsWith('…'));
+  assert.ok(long.question.length <= 160);
+  for (const bad of [null, '', '   ', 42, { x: 1 }]) {
+    const n = docket.normalizeMatter({ id: 1, title: 't', context: bad, question: bad }, at);
+    assert.equal(n.context, docket.SOURCE_CONTEXT.criteria_uat, 'falls back to the source sentence');
+    assert.ok(!('question' in n));
+  }
+  assert.equal(docket.normalizeMatter({ id: 1, title: 't' }, { source: 'nobody_named', building: 'review' }).context, undefined, 'an unknown source invents nothing');
+});
+
+test('the Review card asks a real question and names the goal, the shipped work and what the sign-off closes', () => {
+  const c = { id: 9, criterion_md: 'Builders can sign in with **Google**', goal_id: 7, goal_title: 'Google sign-in', shipped_total: 3, backend_only: false };
+  const m = lifecycleDocket.uatMatter(c, {});
+  assert.equal(m.question, 'Does this work on the live site now?');
+  assert.match(m.context, /The promise: "Builders can sign in with Google"/);
+  assert.match(m.context, /done-when promises of the goal "Google sign-in"/);
+  assert.match(m.context, /All 3 tasks built for it have shipped/);
+  assert.match(m.context, /record a short video/);
+  assert.match(m.context, /the goal is achieved once all its promises are closed/);
+  assert.equal(m.title, c.criterion_md, 'the title stays the promise itself (desks and the street list read it)');
+  const back = lifecycleDocket.uatMatter({ ...c, backend_only: true, shipped_total: 1, goal_title: null }, {});
+  assert.match(back.question, /Check it and sign it off/);
+  assert.match(back.context, /nothing to see on screen/);
+  assert.match(back.context, /The one task built for it has shipped/);
+  assert.match(back.context, /of this version/);
+});
+
+test('every other source names what it belongs to', () => {
+  const lc = lifecycleDocket;
+  assert.match(lc.overrideMatter({ id: 1, task_id: 4, task_title: 'Fix login', requester_login: 'kai' }, true).context, /"Fix login".*failed/);
+  assert.match(lc.removalMatter({ proposal_task_id: 2, title: 'x', goal_title: 'Docs' }).context, /goal "Docs"/);
+  assert.match(lc.joinRequestMatter({ id: 3, goal_id: 5, goal_title: 'Maps', display_name: 'Ana' }, false).context, /Ana asks to join the team of the goal "Maps"/);
+  assert.match(lc.joinRequestMatter({ id: 3, goal_id: 5, goal_title: 'Maps' }, true).context, /^You asked to join/);
+  assert.match(ideasDocket.blockerDocketMatter({ id: 1, title: 'x', blocking_task_ids: [1, 2] }, true).context, /2 tasks are stopped/);
+  const r = reportsRoute.redteamDocketMatter({ id: 2, title: 'No limit on tries', status: 'open', target: '/login', severity: 'high' });
+  assert.equal(r.question, 'Is this security flaw real?');
+  assert.match(r.context, /flaw in this project itself \(in \/login\), rated high\. "No limit on tries"/);
+  const a = accessRoute.accessRequestDocketMatter({ id: 1, github_login: 'kai', display_name: 'Kai', vouched: true });
+  assert.equal(a.question, 'Let Kai join this project?');
+  assert.match(a.context, /GitHub: kai/);
+  const [u] = coreUpdate.coreUpdateDocketMatters({ reading: 'ok', behind: true, latest: '1.25.0', running: '1.24.1' });
+  assert.match(u.context, /runs 1\.24\.1; 1\.25\.0 is out/);
+  assert.match(moduleRechecks.moduleRecheckMatter({ version_id: 7, module_key: 'image-tools', version: '1.2.0', security_failed: true }, true).context, /image-tools is a module.*failed its automatic security check/);
+  const b = treasury.borrowMatter({ id: 1, goal_id: 3, spent_usd: 20, budget_usd: 20, amount_usd: 10, filed_at: null }, { title: 'Maps' });
+  assert.match(b.context, /Maps has spent \$20/);
+  assert.match(b.question, /^Lend Maps/);
+});
+
+test('board sittings say what is being decided and by what rule', () => {
+  const item = (subject_type, pass_rule) => ({ id: 1, subject_type, subject_id: 1, subject: { title: 'An idea', author_id: 9 }, constitution: { pass_rule }, votes: [], closed_at: null });
+  assert.match(docket.boardMatter(item('full_idea', 'first_ratifier'), { viewerId: 1, members: [] }).context, /becomes part of the plan.*One yes decides it\./);
+  assert.match(docket.boardMatter(item('constitutional_amendment', 'majority'), { viewerId: 1, members: [] }).context, /change to the charter.*more than half/);
+  assert.match(docket.boardMatter(item('genesis_stage', 'consent'), { viewerId: 1, members: [] }).context, /founding stage.*unless someone objects/);
+});
+
+// a DOM just big enough for drawAsk
+function fakeDoc() {
+  const make = (tag) => ({
+    tag, className: '', textContent: '', children: [], attrs: {},
+    setAttribute(k, v) { this.attrs[k] = v; }, appendChild(c) { this.children.push(c); return c; }, addEventListener() {},
+  });
+  return { createElement: make, createTextNode: (t) => ({ tag: '#text', textContent: t, children: [] }) };
+}
+function find(node, cls) {
+  if (node.className && String(node.className).split(' ').includes(cls)) return node;
+  for (const c of node.children || []) { const hit = find(c, cls); if (hit) return hit; }
+  return null;
+}
+
+test('the hall carries context and question to the card, and the card draws the context under its question', () => {
+  const matter = docket.normalizeMatter(lifecycleDocket.uatMatter({ id: 9, criterion_md: 'Builders can sign in with Google', goal_title: 'Google sign-in', shipped_total: 3 }, {}), at);
+  const model = living.livingModel({ docket: { matters: [matter] }, now: Date.now() });
+  const ask = model.city.asks.find((x) => x.id === matter.id);
+  assert.ok(ask, 'the matter is an ask');
+  assert.equal(ask.raw.question, 'Does this work on the live site now?');
+  assert.equal(ask.raw.context, matter.context);
+  const cv = deck.cardView(ask, {});
+  assert.equal(cv.question, 'Does this work on the live site now?');
+  assert.equal(cv.context, matter.context);
+  const card = deck.drawAsk(fakeDoc(), cv, {}, {});
+  const q = find(card, 'ask__q');
+  const ctx = find(card, 'ask__ctx');
+  assert.ok(q && ctx, 'question and context are both drawn');
+  assert.equal(ctx.textContent, matter.context);
+  assert.ok(card.children.indexOf(ctx) === card.children.indexOf(q) + 1, 'the context sits right under the question');
+});
+
+test('a blocker read straight from GET /blockers carries the docket\'s blocker sentence', () => {
+  const model = living.livingModel({ blockers: [{ id: 4, title: 'Pick a host', status: 'open', created_at: '2026-10-01T00:00:00Z' }], now: Date.now() });
+  const ask = model.city.asks.find((x) => x.id === 'blockers:4');
+  assert.equal(ask.raw.context, docket.SOURCE_CONTEXT.blockers, 'the two copies of the sentence agree');
+});

package/tests/government_treasury.mjs

@@ -67,7 +67,7 @@ function project({ pots = [], borrows = [], cap = null, spend = {}, lastMonth =
       return { rows: [{ month: params[0], total_usd: thisMonth }, ...(st.lastMonth ? [{ month: params[1], total_usd: st.lastMonth }] : [])] };
     }
     if (/^SELECT t\.goal_id, COALESCE\(SUM\(cl\.amount_usd\), 0\) AS total_usd FROM cost_log cl JOIN tasks t/.test(s)) {
-      assert.equal(params[0], '2026-10');
+      assert.match(params[0], /^\d{4}-\d{2}$/); // the month asked for: NOW's in the direct cases (pinned by t.month below), the real clock's over the route
       return { rows: Object.entries(st.spend).map(([goal_id, total_usd]) => ({ goal_id, total_usd })) };
     }
     if (/^SELECT goal_id, budget_usd, set_by, set_at FROM government_pots/.test(s)) return { rows: st.pots };

package/tests/governor_docket.mjs

@@ -98,7 +98,9 @@ test('normalizeMatter: the one shape, prefixed id, ISO dates', () => {
   assert.deepEqual(m.proposer, { id: '3', login: 'theo', name: null });
   assert.deepEqual(m.tally, { for: 2, against: 1, open: 2, needs: 'x' });
   assert.deepEqual(m.ref, { type: 'a', id: '5' });
-  assert.deepEqual(Object.keys(m).sort(), ['building', 'deadline', 'href', 'id', 'opened_at', 'proposer', 'ref', 'rule', 'short', 'source', 'state', 'tally', 'title', 'where'].sort());
+  // `context` is the source's own sentence when the matter brought none (task 1005013)
+  assert.deepEqual(Object.keys(m).sort(), ['building', 'context', 'deadline', 'href', 'id', 'opened_at', 'proposer', 'ref', 'rule', 'short', 'source', 'state', 'tally', 'title', 'where'].sort());
+  assert.equal(m.context, docket.SOURCE_CONTEXT.access_requests);
 });
 
 test('normalizeMatter carries a matter\'s detail for the card\'s "more" only as bounded text (task 1004566)', () => {

package/tests/hall_ai_studio.mjs

@@ -53,13 +53,37 @@ test('the receipt: our key splits the provider and our markup; an own key charge
   const ours = lib.receipt(done, 1.08);
   assert.deepEqual(ours.rows, [['Paid with', 'your balance'], ['OpenRouter', '$0.0390'], ['Our 8%', '$0.0031'], ['You paid', '$0.0421']]);
   const gemini = lib.receipt(dated(fixture('ai-studio__requests__own')).request, 1.08);
-  assert.deepEqual(gemini.rows, [['Paid with', 'your own Gemini key'], ['Cost', 'not reported']]);
+  assert.deepEqual(gemini.rows, [['Paid with', 'your own Gemini key'], ['Cost', 'about $0.0640']]);
+  assert.match(gemini.note, /estimate/);
   assert.match(gemini.note, /We charged nothing/);
   const openrouter = lib.receipt({ status: 'done', key_source: 'own', provider_cost_micro: 39000 }, 1.08);
   assert.deepEqual(openrouter.rows, [['Paid with', 'your own OpenRouter key'], ['Cost', '$0.0390']]);
   assert.deepEqual(lib.receipt(dated(fixture('ai-studio__requests__failed')).request, 1.08).rows, [], 'a failed run has no receipt');
 });
 
+test('the estimate is the median of finished runs, capped at the ceiling; the cost line reads plainly', () => {
+  assert.deepEqual(lib.estimate([], 500000), { typical: null, max: 500000, basis: 0 });
+  const runs = [{ status: 'done', key_source: 'ours', price_micro: 40000 }, { status: 'done', key_source: 'ours', price_micro: 20000 }, { status: 'done', key_source: 'ours', price_micro: 90000 }, { status: 'failed', key_source: 'ours', price_micro: 999999 }, { status: 'done', key_source: 'own', provider_cost_micro: 30000, price_micro: 0 }];
+  assert.deepEqual(lib.estimate(runs, 500000, true), { typical: 40000, max: 500000, basis: 3 });
+  assert.deepEqual(lib.estimate(runs, 500000, false), { typical: 30000, max: 500000, basis: 1 }, 'an own-key guess uses the provider cost, no markup');
+  assert.equal(lib.estimate([{ status: 'done', key_source: 'ours', price_micro: 900000 }], 500000, true).typical, 500000);
+  assert.equal(lib.costHeadline({ status: 'done', key_source: 'ours', price_micro: 41000 }), 'This cost $0.0410, taken from your balance.');
+  assert.match(lib.costHeadline({ status: 'done', key_source: 'own', provider_cost_micro: null }), /about \$0\.0640 on your Gemini key/);
+  assert.equal(lib.geminiEstimate(3), 142000, 'a reply plus each picture');
+  assert.equal(lib.costHeadline({ status: 'failed', key_source: 'ours', price_micro: 1 }), '');
+});
+
+test('the reply reads as headings, a list and folded code, never raw markup', () => {
+  const fence = '`'.repeat(3);
+  const md = ['### What works', '* **Feel:** the `rule` line', '* Second', '--', `${fence}xml`, '<svg a="1"/>', fence, 'Done <b>x</b>'].join('\n');
+  const html = lib.replyHtml(md, escapeHtml);
+  assert.ok(html.includes('<h3 class="ais-rh">What works</h3>'), html);
+  assert.ok(html.includes('<ul><li><b>Feel:</b> the <code>rule</code> line</li><li>Second</li></ul>'), html);
+  assert.ok(html.includes('<summary>Code from the answer</summary><pre>&lt;svg a=&quot;1&quot;/&gt;</pre></details>'), html);
+  assert.ok(html.includes('<p>Done &lt;b&gt;x&lt;/b&gt;</p>'), html);
+  assert.ok(!html.includes('###') && !html.includes(fence) && !html.includes('<p>--'), html);
+});
+
 test('the month: added, spent, money back and own-key requests, from the ledger', () => {
   const bal = dated(fixture('ai-studio__balance'));
   const sum = lib.monthSummary(bal.ledger, new Date());
@@ -368,6 +392,9 @@ test('page: step 3 sends the request on the card pressed, with copies of the car
   assert.match(p.page.innerHTML, /\$12\.40 left/);
   const ours = p.page.querySelectorAll('[data-pay]').find((b) => b.getAttribute('data-pay') === 'ours');
   await ours.fire('click');
+  assert.match(p.page.querySelector('#ais-confirm').innerHTML, /to make this/, 'the cost is shown before anything is sent');
+  assert.equal(p.calls.filter((c) => c.method === 'POST').length, 0, 'nothing is sent until the artist says yes');
+  await p.page.querySelector('#ais-confirm').querySelector('#ais-confirm-go').fire('click');
   await settle();
   const uploads = p.calls.filter((c) => c.method === 'POST' && c.url.endsWith('/ai-studio/uploads'));
   assert.equal(uploads.length, 3, 'a file goes with one request only, so each carried file is uploaded again');
@@ -470,6 +497,19 @@ test('walls: the studio home shows the AI door only where the module is on', ()
   assert.match(js, /loadAi\(\)\]/);
 });
 
+test('page: Not yet closes the confirm box and sends nothing', async () => {
+  const p = bootPage('?step=make&from=1001');
+  await settle();
+  const ours = p.page.querySelectorAll('[data-pay]').find((b) => b.getAttribute('data-pay') === 'ours');
+  await ours.fire('click');
+  const box = p.page.querySelector('#ais-confirm');
+  assert.ok(box.innerHTML.includes('It will never cost more than $0.50.'), box.innerHTML);
+  await box.querySelector('#ais-confirm-cancel').fire('click');
+  assert.equal(box.innerHTML, '');
+  assert.equal(box.hidden, true);
+  assert.equal(p.calls.filter((c) => c.method === 'POST').length, 0);
+});
+
 test('page: with both own keys saved, step 3 offers one card each and sends the one pressed', async () => {
   const both = { keys: [{ provider: 'openrouter', set: true, last4: '4f2a' }, { provider: 'gemini', set: true, last4: '9c1d' }] };
   assert.deepEqual(lib.ownKeys(both).map((k) => k.provider), ['openrouter', 'gemini']);
@@ -480,6 +520,9 @@ test('page: with both own keys saved, step 3 offers one card each and sends the
   assert.match(p.page.innerHTML, /My Gemini key/);
   const gem = p.page.querySelectorAll('[data-pay]').find((b) => b.getAttribute('data-pay') === 'gemini');
   await gem.fire('click');
+  assert.match(p.page.querySelector('#ais-confirm').innerHTML, /to make this/, 'the cost is shown before anything is sent');
+  assert.equal(p.calls.filter((c) => c.method === 'POST').length, 0, 'nothing is sent until the artist says yes');
+  await p.page.querySelector('#ais-confirm').querySelector('#ais-confirm-go').fire('click');
   await settle();
   const sent = p.calls.find((c) => c.method === 'POST' && c.url.endsWith('/ai-studio/requests'));
   assert.equal(sent.body.pay_with, 'gemini');

package/tests/hall_gov_real_site.mjs

@@ -425,7 +425,7 @@ test('the decision deck on a real site: the docket\'s own asks in their own word
   noPrototype(p, 'deck');
   const deck = p.byId.get('streetDeck');
   assert.equal(deck.hidden, false, 'the deck opens');
-  const docketTitles = fx('government__docket').matters.map((m) => m.title).concat(fx('blockers').blockers.map((b) => b.title));
+  const docketTitles = fx('government__docket').matters.flatMap((m) => [m.title, m.question]).filter(Boolean).concat(fx('blockers').blockers.map((b) => b.title));
   assert.ok(docketTitles.some((t) => deck.textContent.includes(t)), 'a real ask, as its source words it');
   // the format's refusal is the prototype's: a real ask goes to its floor's desk, where its real acts are
   assert.doesNotMatch(deck.textContent, /sent back|until its agent writes it|prototype data|pass it on/, 'no refusal, no key, no seats to pass to');

package/tests/hall_roster_world.mjs

@@ -302,3 +302,13 @@ test('the states files exercise the redesign\'s new states', () => {
   const sessions = JSON.parse(read('sessions.states.json'));
   assert.deepEqual(sessions.states.ledger.expect.visible, ['#stats-scroll', '#sessions-scroll']);
 });
+
+test('the roster draws the circuit divider in CSS, on the first row\'s cell and not the row', () => {
+  const css = read('roster.css');
+  const rule = css.slice(css.indexOf('the circuit divider'));
+  assert.match(rule, /tr:first-child:not\(:has\(\.ledger__empty\)\) td:first-child::before/, 'the traces hang on the first cell');
+  assert.match(rule, /td:first-child::after/, 'and so do the nodes');
+  assert.doesNotMatch(rule, /:has\(\.ledger__empty\)\)::(before|after)/, 'never on the tr itself: a tr pseudo becomes a table cell and shifts the row');
+  assert.match(rule, /background: var\(--ink-faint\)/, 'traces spend the faint ink token');
+  assert.match(rule, /background: var\(--accent\)/, 'nodes spend the accent token');
+});

package/tests/hall_street_depth.mjs

@@ -52,6 +52,12 @@ require(path.join(PUB, 'street-desk.js')); // the line rule's fit, on the global
 const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
 const fx = (name) => JSON.parse(fs.readFileSync(path.join(FX, name + '.json'), 'utf8'));
 const NOW = Date.parse('2026-10-09T14:00:00.000Z');
+// The page reads the clock itself (street-depth.js, GovFeeds.model(raw, Date.now())), and the fixtures are
+// October's: pin the page's clock to NOW so a later real month does not read them as stale and hide a tile.
+class PinnedDate extends Date {
+  constructor(...a) { super(...(a.length ? a : [NOW])); }
+  static now() { return NOW; }
+}
 const clone = (o) => JSON.parse(JSON.stringify(o));
 
 function feeds(over = {}) {
@@ -475,7 +481,7 @@ async function bootPage({ withLiving = true } = {}) {
   const window = { innerWidth: 1440, innerHeight: 900, location: { hash: '' }, localStorage: { getItem: () => 'dark', setItem() {} }, matchMedia: () => ({ matches: true, addEventListener() {} }), addEventListener() {} };
   class MutationObserver { observe() {} }
   window.fetch = fetch;
-  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, MutationObserver, Set });
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date: PinnedDate, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, MutationObserver, Set });
   ctx.globalThis = ctx;
   for (const f of (withLiving ? ['gov-living.js', 'gov-feeds.js'] : []).concat(['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-depth.js', 'street-desk.js', 'street.js'])) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;