@bongos/core 1.21.112 → 1.21.114

package/tests/hall_gov_real_site.mjs

@@ -0,0 +1,655 @@
+// tests/hall_gov_real_site.mjs — ON A REAL SITE THE PROTOTYPE IS NOT THERE
+// (task 1004701: land the living-city prototype as the hall's visual base).
+//
+// WHAT IT GUARDS. The living city, the street, the decision deck, the inside of
+// every building and My agents were built over real reads plus ONE labelled
+// prototype overlay (GET /proto/governor-overlay), served by the hall-preview
+// harness only. Task 1004717 deleted it: no page asks for it any more. This file
+// boots every page with every real fixture, a stale server still answering the
+// overlay route, and requires that:
+//   * no page asks for the overlay, and nothing on any page carries `data-proto`;
+//   * no text the overlay used to invent (a Lead's charter, a law, a prototype
+//     setting, a human rewrite of an ask) appears anywhere in the page's text,
+//     attributes or markup;
+//   * no prototype key, office storey, law book of invented laws or pot is drawn;
+//   * the real reads still draw (the docket's asks, the readings, the real rows);
+//   * a law the project really passed (GET /government/laws, task 1004706) stands
+//     as real, while the overlay's invented laws still do not;
+//   * who leads each building (GET /government/leads, task 1004709) stands as
+//     real: a Lead the government appointed on their building, and the owner on
+//     every unseated one, with nothing marked prototype;
+//   * the shell's seat-gated nav stays today's nav (unknown is never "none").
+// And, as the control, that the same scan DOES find those words when a real read
+// carries them, so a scan that quietly finds nothing cannot pass.
+//
+// Run:  node --test --test-reporter=tap tests/hall_gov_real_site.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const FX = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(FX, name + '.json'), 'utf8'));
+const GovPositions = require(path.join(PUB, 'gov-positions.js'));
+const BUILDINGS = ['charter', 'rules', 'disputes', 'people', 'planning', 'automation', 'review', 'release', 'treasury'];
+const OVERLAY_URL = '/api/bongos/proto/governor-overlay';
+
+// ── the deleted overlay's own words ─────────────────────────────────────────
+// Phrases the prototype overlay used to invent (its laws, a Lead's charter, its
+// prototype settings, a rewrite of an ask), that no real fixture and no page
+// source holds: if one of these is on a page, something invented it.
+const PAGE_SOURCES = ['city.html', 'street.html', 'my-agents.html', 'city.js', 'city-draw.js', 'street.js', 'street-draw.js', 'street-depth.js',
+  'street-deck.js', 'street-office.js', 'street-inside.js', 'street-card.js', 'street-desk.js', 'street-amend.js', 'my-agents.js', 'gov-living.js', 'gov-feeds.js', 'gov-positions.js']
+  .map(read).join('\n');
+const REAL_TEXT = fs.readdirSync(FX).filter((f) => f.endsWith('.json')).map((f) => fs.readFileSync(path.join(FX, f), 'utf8')).join('\n');
+const OVERLAY_PHRASES = ['Ask everything up front', 'Build the approved design exactly', 'Planning floors: goals, priorities, the order of work.',
+  'When an agent is stuck', 'Go live without asking', 'Judge a high-severity security report?'];
+// a stale server that still answers the old route, with those words in it
+const OLD_OVERLAY = {
+  _proto: 'Prototype data: concepts not yet in the database',
+  owner: { id: '3' },
+  laws: [{ id: 'skip', text: OVERLAY_PHRASES[0] }, { id: 'land', text: OVERLAY_PHRASES[1] }],
+  leads: [{ building: 'planning', lead: '1000025', charter: { scope: OVERLAY_PHRASES[2] }, deputies: [], committees: [] }],
+  personal_settings: [{ key: 'on_stuck', label: OVERLAY_PHRASES[3], values: ['ask'], value: 'ask' }, { key: 'auto_go_live', label: OVERLAY_PHRASES[4], values: ['no'], value: 'no' }],
+  asks: [{ id: 'redteam_reports:1000009', question: OVERLAY_PHRASES[5], options: [{ key: 'a', label: 'A', result: 'a' }, { key: 'b', label: 'B', result: 'b' }], recommend: { key: 'a', why: 'x' }, waits_on: 'owner', if_nobody_answers: 'x' }],
+};
+const esc = (s) => s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+// ── one fake DOM for every page ─────────────────────────────────────────────
+// Every element of the page's HTML that has an id stands as a node, with its
+// attributes and its static markup; scripts build the rest with createElement or
+// innerHTML. Enough of querySelector/closest/matches for the pages' own selectors.
+function fakeDom(htmlFile) {
+  const byId = new Map();
+  const roots = [];
+  const parseSel = (sel) => sel.split(',').map((s) => s.trim()).filter(Boolean);
+  const matchOne = (el, w) => {
+    let m;
+    if ((m = /^\[([\w-]+)="([^"]*)"\]$/.exec(w))) return el.attrs[m[1]] === m[2];
+    if ((m = /^\[([\w-]+)\]$/.exec(w))) return m[1] in el.attrs;
+    if ((m = /^\.([\w-]+)$/.exec(w))) return String(el.className).split(' ').includes(m[1]);
+    if ((m = /^#([\w-]+)$/.exec(w))) return el.attrs.id === m[1];
+    if (/^[a-z]+$/.test(w)) return el.tagName === w;
+    return false;
+  };
+  const mk = (tag) => {
+    const el = {
+      tagName: tag, attrs: {}, kids: [], className: '', listeners: {}, _text: '', _html: '', parentNode: null,
+      // the property and the attribute are one, as in a browser (a page may use either)
+      get hidden() { return 'hidden' in this.attrs; },
+      set hidden(v) { if (v) this.attrs.hidden = ''; else delete this.attrs.hidden; },
+      style: { setProperty(k, v) { this[k] = v; }, removeProperty(k) { delete this[k]; } },
+      clientWidth: 1440, clientHeight: 708, offsetLeft: 0, offsetTop: 0, scrollLeft: 0, scrollTop: 0,
+      get children() { const a = this.kids.slice(); a[Symbol.isConcatSpreadable] = false; return a; },
+      get firstChild() { return this.kids[0] || null; },
+      setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+      getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+      hasAttribute(k) { return k in this.attrs; },
+      removeAttribute(k) { delete this.attrs[k]; },
+      appendChild(c) { this.kids.push(c); c.parentNode = this; return c; },
+      insertBefore(c, ref) { const i = this.kids.indexOf(ref); if (i < 0) this.kids.push(c); else this.kids.splice(i, 0, c); c.parentNode = this; return c; },
+      removeChild(c) { this.kids = this.kids.filter((x) => x !== c); return c; },
+      remove() { if (this.parentNode) this.parentNode.removeChild(this); },
+      addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+      removeEventListener() {},
+      fire(t, e) { (this.listeners[t] || []).forEach((fn) => fn({ type: t, target: this, preventDefault() {}, stopPropagation() {}, ...e })); },
+      focus() {}, blur() {},
+      matches(sel) { return parseSel(sel).some((w) => matchOne(this, w)); },
+      closest(sel) { let n = this; while (n) { if (n.matches && n.matches(sel)) return n; n = n.parentNode; } return null; },
+      querySelectorAll(sel) { const out = []; const walk = (n) => n.kids.forEach((k) => { if (k.matches(sel)) out.push(k); walk(k); }); walk(this); return out; },
+      querySelector(sel) { return this.querySelectorAll(sel)[0] || null; },
+      getBoundingClientRect() { return { left: 0, top: 0, right: 1440, bottom: 708, width: 1440, height: 708, x: 0, y: 0 }; },
+      set textContent(v) { this._text = String(v); this._html = ''; this.kids = []; },
+      get textContent() { return this._text + this.kids.map((k) => k.textContent || '').join(''); },
+      set innerHTML(v) { this._html = String(v); this._text = ''; this.kids = []; },
+      get innerHTML() { return this._html; },
+    };
+    el.classList = {
+      add: (...c) => { const s = new Set(String(el.className).split(' ').filter(Boolean)); c.forEach((x) => s.add(x)); el.className = [...s].join(' '); },
+      remove: (...c) => { el.className = String(el.className).split(' ').filter((x) => x && !c.includes(x)).join(' '); },
+      toggle: (c, on) => { const has = String(el.className).split(' ').includes(c); const want = on === undefined ? !has : !!on; if (want) el.classList.add(c); else el.classList.remove(c); return want; },
+      contains: (c) => String(el.className).split(' ').includes(c),
+    };
+    return el;
+  };
+  const html = read(htmlFile).replace(/<!--[\s\S]*?-->/g, '');
+  const VOID = /^(meta|link|img|input|br|hr|source|use|path|circle|rect|line|polygon|stop)$/;
+  // [start, end) of an element's inner markup, its own tag balanced
+  const innerOf = (tag, from) => {
+    const re = new RegExp(`<(/?)${tag}\\b[^>]*?(/?)>`, 'g');
+    re.lastIndex = from;
+    let depth = 1, m;
+    while ((m = re.exec(html))) {
+      if (m[2]) continue;
+      depth += m[1] ? -1 : 1;
+      if (!depth) return [from, m.index];
+    }
+    return [from, from];
+  };
+  const spans = [];
+  for (const m of html.matchAll(/<([a-z][a-z0-9]*)\b([^>]*)>/g)) {
+    const idm = /\bid="([A-Za-z][\w-]*)"/.exec(m[2]);
+    if (!idm) continue;
+    const el = mk(m[1]);
+    for (const a of m[2].matchAll(/\s([\w-]+)(?:="([^"]*)")?/g)) {
+      if (a[1] === 'class') el.className = a[2] || '';
+      else el.setAttribute(a[1], a[2] === undefined ? '' : a[2]);
+    }
+    const inner = VOID.test(m[1]) || /\/$/.test(m[2]) ? [0, 0] : innerOf(m[1], m.index + m[0].length);
+    spans.push({ el, outer: [m.index, inner[1]], inner });
+    roots.push(el);
+  }
+  // each element's own static markup: its inner markup less every id'd element inside it
+  // (those stand as nodes of their own, and are judged by their own `hidden`)
+  for (const s of spans) {
+    let text = '';
+    let at = s.inner[0];
+    spans.filter((o) => o !== s && o.outer[0] >= s.inner[0] && o.outer[0] < s.inner[1])
+      .sort((a, b) => a.outer[0] - b.outer[0])
+      .forEach((o) => { if (o.outer[0] >= at) { text += html.slice(at, o.outer[0]); at = Math.max(at, o.outer[1]); } });
+    text += html.slice(at, s.inner[1]);
+    s.el._html = text;
+    // the innermost id'd element holding it: a hidden one hides it too
+    const holders = spans.filter((o) => o !== s && s.outer[0] >= o.inner[0] && s.outer[0] < o.inner[1]);
+    s.el.staticParent = holders.sort((a, b) => b.inner[0] - a.inner[0])[0]?.el || null;
+  }
+  const document = {
+    documentElement: mk('html'),
+    getElementById: (id) => byId.get(id) || null,
+    querySelector: (sel) => { for (const r of roots) { if (r.matches(sel)) return r; const f = r.querySelector(sel); if (f) return f; } return null; },
+    querySelectorAll: (sel) => roots.flatMap((r) => (r.matches(sel) ? [r] : []).concat(r.querySelectorAll(sel))),
+    createElement: (t) => mk(t), createElementNS: (_n, t) => mk(t),
+    createTextNode: (t) => { const n = mk('#text'); n._text = String(t); return n; },
+    addEventListener() {},
+  };
+  return { document, byId, roots };
+}
+
+// Everything a page shows, as one string (text, markup and attribute values of
+// every element not hidden), and every shown element carrying data-proto.
+function dump(roots) {
+  const parts = [];
+  const proto = [];
+  const shut = (el) => el.hidden;
+  const walk = (el) => {
+    if (shut(el)) return;
+    for (let p = el.staticParent; p; p = p.staticParent) if (shut(p)) return;
+    parts.push(el._text, el._html, ...Object.values(el.attrs));
+    if ('data-proto' in el.attrs) proto.push((el.attrs.id || el.tagName) + '.' + el.className);
+    if (/\sdata-proto(?=[\s>=])/.test(el._html)) proto.push((el.attrs.id || el.tagName) + ' (markup)');
+    el.kids.forEach(walk);
+  };
+  roots.forEach(walk);
+  return { text: parts.join('\n'), proto, shown: parts.length };
+}
+
+// ── the feeds: every real fixture, and the overlay as production answers it ──
+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/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)
+  '/api/bongos/government/laws': 'government__laws',
+  // the strictness presets as the route answers the hub (no law, so no preset in force; task 1004715)
+  '/api/bongos/government/presets': 'government__presets',
+};
+// a law a project really passed, as GET /government/laws answers it (not one of the
+// overlay's: the words are this test's own, so the overlay scan cannot excuse them)
+const A_REAL_LAW = 'Every screen change carries two shots';
+const REAL_BOOK = {
+  laws: [{
+    id: '11', text: A_REAL_LAW, effect_on_ai: 'Agents attach a before and an after picture to screen work.', locks: [],
+    in_force: true, passed_at: '2026-10-09T12:00:00.000Z', repealed_at: null, repealed_by_item_id: null,
+    passed_by: { item_id: '31', href: '/board-room?item=31', government: 'Timocratic Republic', pass_rule: 'unanimous', proposer: { id: '42', login: 'ada', name: 'Ada' }, yes: [] },
+  }],
+  in_force: 1,
+};
+let lawBook = null; // a test may serve REAL_BOOK in place of the hub's empty book
+// GET /me's laws block as the server answers it on a project with a law in force
+// (task 1004707): what every session reads, and what the lock did to this viewer
+let meLaws = null;
+const ME_LAWS = {
+  inject: true,
+  contract: 'Project laws — passed by a vote of this project\'s government.\n1. ' + A_REAL_LAW,
+  laws: [{ id: '11', no: 1, text: A_REAL_LAW, effect_on_ai: 'Agents attach a before and an after picture to screen work.', locks: [{ setting: 'verbosity', value: 'detailed' }] }],
+  locks: [{ setting: 'verbosity', law_id: '11', law_no: 1, law_text: A_REAL_LAW, value: 'detailed', route: 'interaction', enforced: true, from: 'concise', to: 'detailed' }],
+};
+// A stored ask (task 1004703), as GET /government/docket carries it on a matter
+// whose agent wrote its card in the ask shape. Its words are this test's own, so
+// the overlay scan cannot excuse them.
+const A_REAL_ASK = {
+  question: 'Pick the host for the new site?',
+  options: [
+    { key: 'cheap', label: 'The cheap host', result: 'Ten dollars a month, slower builds.', act: 'go ahead' },
+    { key: 'fast', label: 'The fast host', result: 'Forty dollars a month, quick builds.' },
+  ],
+  recommend: { key: 'cheap', why: 'The site is small for now.' },
+  waits_on: 'owner',
+  if_nobody_answers: 'The site waits, unbuilt.',
+  detail: null,
+  written_at: '2026-10-09T12:00:00.000Z',
+};
+let docketAsks = false; // a test may serve the docket with every open matter carrying A_REAL_ASK
+// Who leads each building, as GET /government/leads answers (task 1004709): Planning
+// led by a builder the government appointed, every other building the owner's. The
+// Lead's name and charter are this test's own words, so the overlay scan cannot excuse them.
+const A_REAL_LEAD = 'Quill Appointee';
+const LEADS_READ = {
+  buildings: BUILDINGS.map((b) => ({
+    building: b, name: b,
+    lead: b === 'planning' ? { id: '1', building: b, builder: { id: '777', login: 'quill', name: A_REAL_LEAD }, charter: 'Orders the work by what ships next.', since: '2026-10-09T12:00:00.000Z', appointed_by: { item_id: '40', href: '/board-room?item=40' } } : null,
+    answers: b === 'planning' ? { seat: 'lead:planning', builder_ids: ['777'], fell_to_owner: false } : { seat: 'owner', builder_ids: ['3'], fell_to_owner: true },
+  })),
+  owner: { seat: 'owner', rank: 'archon', builders: [{ id: '3', login: 'builder-2013', name: 'Builder 2013' }] },
+  seated: 1,
+};
+let leadsBook = null; // a test may serve LEADS_READ; otherwise the read answers 404 (an older server)
+// The treasury (task 1004712), as GET /government/treasury answers it: one goal's pot,
+// dry, with its borrow open on the docket (the fixture's treasury_spending:1).
+const TREASURY_READ = (() => {
+  const t = fx('government__treasury');
+  t.pots = [t.pots.find((p) => p.dry)];
+  return t;
+})();
+let treasuryBook = null; // a test may serve TREASURY_READ; otherwise the read answers 404 (an older server)
+function makeFetch(withOverlay, calls) {
+  return (url, init) => {
+    calls.push(url);
+    if (init && init.method && init.method !== 'GET') return Promise.resolve({ ok: false, status: 501, json: async () => ({}) });
+    if (url === '/api/bongos/government/docket' && docketAsks) {
+      const d = fx('government__docket');
+      d.matters.forEach((m) => { if (m.state === 'needs') m.ask = JSON.parse(JSON.stringify(A_REAL_ASK)); });
+      return Promise.resolve({ ok: true, status: 200, json: async () => d });
+    }
+    if (url === '/api/bongos/government/laws' && lawBook) return Promise.resolve({ ok: true, status: 200, json: async () => JSON.parse(JSON.stringify(lawBook)) });
+    if (url === '/api/bongos/government/leads' && leadsBook) return Promise.resolve({ ok: true, status: 200, json: async () => JSON.parse(JSON.stringify(leadsBook)) });
+    if (url === '/api/bongos/government/treasury' && treasuryBook) return Promise.resolve({ ok: true, status: 200, json: async () => JSON.parse(JSON.stringify(treasuryBook)) });
+    if (url === '/api/bongos/me' && meLaws) {
+      const me = fx('me');
+      me.laws = JSON.parse(JSON.stringify(meLaws));
+      me.interaction.effective = { ...me.interaction.effective, verbosity: 'detailed' };
+      return Promise.resolve({ ok: true, status: 200, json: async () => me });
+    }
+    if (url === OVERLAY_URL && withOverlay) return Promise.resolve({ ok: true, status: 200, json: async () => JSON.parse(JSON.stringify(OLD_OVERLAY)) });
+    const name = FEED[url];
+    if (!name) return Promise.resolve({ ok: false, status: 404, json: async () => ({ error: { code: 'not_found' } }) });
+    return Promise.resolve({ ok: true, status: 200, json: async () => fx(name) });
+  };
+}
+function sandbox(window, document, fetch) {
+  class MutationObserver { observe() {} disconnect() {} }
+  const ctx = vm.createContext({
+    window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent,
+    isNaN, isFinite, Map, Set, setTimeout, clearTimeout, MutationObserver, Symbol, Error, RegExp, Boolean,
+  });
+  ctx.globalThis = ctx;
+  return ctx;
+}
+function baseWindow(hash = '') {
+  const store = new Map();
+  const ls = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)), removeItem: (k) => store.delete(k) };
+  return {
+    innerWidth: 1440, innerHeight: 900, location: { hash, href: '', search: '', pathname: '/' },
+    localStorage: ls, sessionStorage: ls,
+    matchMedia: () => ({ matches: true, addEventListener() {} }), addEventListener() {}, removeEventListener() {},
+    history: { pushState() {}, replaceState() {} },
+  };
+}
+const settle = async (n = 8) => { for (let i = 0; i < n; i++) await new Promise((r) => setImmediate(r)); };
+
+async function bootCity(withOverlay) {
+  const { document, byId, roots } = fakeDom('city.html');
+  const calls = [];
+  const window = baseWindow();
+  window.fetch = makeFetch(withOverlay, calls);
+  const ctx = sandbox(window, document, window.fetch);
+  // city.html loads the deck's card and sender for the card's first ask (task 1004702)
+  for (const f of ['gov-living.js', 'city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street-deck.js', 'city.js']) vm.runInContext(read(f), ctx, { filename: f });
+  await window.GovCityPage.ready;
+  await settle();
+  return { byId, roots, calls, window };
+}
+async function bootStreet(hash, withOverlay) {
+  const { document, byId, roots } = fakeDom('street.html');
+  const calls = [];
+  const window = baseWindow(hash);
+  window.fetch = makeFetch(withOverlay, calls);
+  const ctx = sandbox(window, document, window.fetch);
+  for (const f of ['gov-living.js', 'gov-feeds.js', 'city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-depth.js',
+    'street-desk.js', 'street-amend.js', 'street-deck.js', 'street-office.js', 'street.js']) vm.runInContext(read(f), ctx, { filename: f });
+  await window.GovStreetPage.ready;
+  await settle();
+  return { byId, roots, calls, window };
+}
+async function bootMyAgents(withOverlay) {
+  const { document, byId, roots } = fakeDom('my-agents.html');
+  const calls = [];
+  const window = baseWindow();
+  const fetch = makeFetch(withOverlay, calls);
+  window.fetch = fetch;
+  // the page's client: the same reads, through the same 404
+  window.BongosClient = {
+    createClient: () => ({
+      request: (method, p) => fetch(p, { method }).then(async (r) => ({ ok: r.ok, status: r.status, data: r.ok ? await r.json() : null })),
+    }),
+  };
+  const ctx = sandbox(window, document, fetch);
+  for (const f of ['gov-living.js', 'gov-positions.js', 'my-agents.js']) vm.runInContext(read(f), ctx, { filename: f });
+  await settle(12);
+  return { byId, roots, calls, window };
+}
+function noPrototype(page, where, { seatsRead = false } = {}) {
+  const { text, proto, shown } = dump(page.roots);
+  assert.ok(shown >= 3, `${where}: the scan saw the page (${shown} elements)`);
+  assert.deepEqual(proto, [], `${where}: nothing shown carries data-proto`);
+  assert.ok(!page.calls.includes(OVERLAY_URL), `${where}: no overlay is asked for`);
+  const leaked = OVERLAY_PHRASES.filter((s) => text.includes(s) || text.includes(esc(s)));
+  assert.deepEqual(leaked, [], `${where}: no word the overlay used to invent is on the page`);
+  // who leads or holds a building is known only from GET /government/leads (task
+  // 1004709); without that read the page names no Lead and no owner's seat
+  if (!seatsRead) assert.doesNotMatch(text, /\bLeads?\b|\bled by\b|held by the owner|the owner holds/, `${where}: no Lead, no owner's seat`);
+  return text;
+}
+
+// ── the control: the scan finds those words when a real read carries them ───
+test('control: the phrases are no real fixture\'s and no page\'s; a stale overlay route changes nothing; a real law carrying one shows', async () => {
+  for (const s of OVERLAY_PHRASES) assert.ok(!REAL_TEXT.includes(s) && !PAGE_SOURCES.includes(s), s);
+  // a stale server still answers the old route: no page asks for it, nothing of it shows
+  const pages = [['city', await bootCity(true)], ['street', await bootStreet('', true)], ['deck', await bootStreet('#deck', true)],
+    ['inside planning', await bootStreet('#building=planning', true)], ['my agents', await bootMyAgents(true)]];
+  for (const [where, page] of pages) noPrototype(page, where + ' (a stale overlay route)');
+  for (const f of ['city.js', 'gov-feeds.js', 'my-agents.js', 'street.js', 'street-depth.js']) assert.doesNotMatch(read(f), /governor-overlay/, f + ' names no overlay route');
+  // no prototype tag is left in the code of any living-city page, the shell or their sheets
+  // (comments may still tell the history; code, markup and storage keys may not)
+  const code = (src) => src.replace(/<!--[\s\S]*?-->/g, '').replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"`\\])\/\/.*$/gm, '$1');
+  for (const f of ['city.html', 'street.html', 'my-agents.html', 'city.js', 'city-draw.js', 'street.js', 'street-draw.js', 'street-depth.js', 'street-deck.js',
+    'street-office.js', 'street-inside.js', 'my-agents.js', 'gov-living.js', 'gov-feeds.js', 'gov-positions.js', 'shell.js', 'city.css', 'street.css', 'street-deck.css', 'my-agents.css']) {
+    assert.doesNotMatch(code(read(f)), /data-proto|proto-tag|proto-key|proto_note|overlay_note|protoAsk|['"]proto[-:'"]|\.proto\b|\bproto:/, f + ': no prototype tag in its code');
+  }
+  // the scan is not vacuous: a real law in those words is on the street
+  lawBook = { laws: [{ ...REAL_BOOK.laws[0], text: OVERLAY_PHRASES[0] }], in_force: 1 };
+  try {
+    const p = await bootStreet('', false);
+    const { text } = dump(p.roots);
+    assert.ok(text.includes(OVERLAY_PHRASES[0]) || text.includes(esc(OVERLAY_PHRASES[0])), 'the scan sees the words when a page shows them');
+  } finally { lawBook = null; }
+});
+
+// ── a real site ─────────────────────────────────────────────────────────────
+test('the city on a real site: the real city, no Lead, law, pot, build-out, rewrite or prototype key', async () => {
+  const p = await bootCity(false);
+  noPrototype(p, 'city');
+  assert.doesNotMatch(read('city.html'), /cityKey|data-proto/, 'no prototype key');
+  assert.equal(p.byId.get('cityHits').children.length, 9, 'the nine buildings still answer');
+  assert.ok(p.byId.get('cityHits').children.every((b) => !/led by/.test(b.attrs['aria-label'])), 'nobody "leads" a building');
+  assert.match(p.byId.get('cityLine').textContent, /\d+ agents? working/, 'the real reads still count');
+  // a building's card names nobody as holding it, and carries no rewritten ask:
+  // its first ask (task 1004702) is the docket's own, in its own words
+  for (const b of BUILDINGS) {
+    p.byId.get('cityHits').children.find((h) => h.attrs['data-building'] === b).fire('click');
+    const card = p.byId.get('cityCard');
+    assert.equal(card.attrs['data-building'], b);
+    assert.doesNotMatch(card.textContent, /\bLead\b|owner/, `${b}: no Lead, no owner's seat`);
+    const asks = card.querySelectorAll('.city-ask');
+    assert.ok(asks.length <= 1, `${b}: at most its first ask`);
+    // answers are drawn only for a matter whose agent stored its ask (the harness's treasury borrow)
+    const stored = fx('government__docket').matters.filter((m) => m.ask).map((m) => m.ask.question);
+    if (asks.length && asks[0].querySelectorAll('.ask__opt').length) assert.ok(stored.includes(asks[0].querySelectorAll('.ask__q')[0].textContent), b + ': answers only on a stored ask');
+    noPrototype(p, 'city card ' + b);
+  }
+});
+
+test('the street on a real site: the real street, its readings and asks, no prototype layer', async () => {
+  const p = await bootStreet('', false);
+  noPrototype(p, 'street');
+  assert.doesNotMatch(read('street.html'), /streetDepthKey|data-proto/, 'no prototype key');
+  assert.ok(p.byId.get('streetSigns').children.some((a) => !a.hidden), 'the docket\'s readings stand');
+  assert.match(p.byId.get('hudNeeds').textContent, /^\d+$/, 'the header counts the real asks');
+});
+
+test('the decision deck on a real site: the docket\'s own asks in their own words, no rewrite, no invented ask', async () => {
+  const p = await bootStreet('#deck', false);
+  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));
+  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');
+  const walk = (el, out = []) => { el.kids.forEach((k) => { out.push(k); walk(k, out); }); return out; };
+  const desk = walk(deck).find((k) => k.className === 'ask__desk');
+  assert.ok(desk, 'the card sends you to its desk');
+  assert.match(desk.attrs.href, /^\/builders\/street#building=[a-z]+$/);
+  assert.match(walk(deck).find((k) => /\bask__waits\b/.test(k.className)).textContent, /^waits on (you|others)$/, 'it waits on you, or on others unnamed');
+});
+
+test('a matter whose agent stored its ask: the deck draws the card, as real, on a real site', async () => {
+  docketAsks = true;
+  try {
+    // at Planning, where the blockers stand: a stored answer's act ('go ahead') is the blocker's own decide chip
+    const p = await bootStreet('#deck=planning', false);
+    noPrototype(p, 'deck with stored asks');
+    const deck = p.byId.get('streetDeck');
+    const walk = (el, out = []) => { el.kids.forEach((k) => { out.push(k); walk(k, out); }); return out; };
+    const all = walk(deck);
+    const card = all.find((k) => k.tagName === 'article' && /\bask\b/.test(k.className));
+    assert.ok(card, 'a card is drawn');
+    const q = all.find((k) => /\bask__q\b/.test(k.className));
+    assert.equal(q.textContent, A_REAL_ASK.question, 'its question is the stored one');
+    assert.equal('data-proto' in q.attrs, false, 'and its words are not marked prototype');
+    const opts = all.filter((k) => /\bask__opt\b/.test(k.className) && k.tagName === 'button');
+    assert.deepEqual(opts.map((o) => o.attrs['data-key']), ['cheap', 'fast'], 'its two tap answers');
+    assert.equal('aria-disabled' in opts[0].attrs, false, 'the pick takes the real decide act of the blocker, so it is live');
+    assert.ok(deck.textContent.includes('Ten dollars a month, slower builds.'), 'each with its one-line result');
+    assert.ok(deck.textContent.includes("I'd pick the cheap host. The site is small for now."), 'the pick and why, in the asker\'s voice');
+    assert.ok(deck.textContent.includes('Left alone, the site waits, unbuilt'), 'what happens if nobody answers');
+    assert.ok(all.some((k) => /\bask__pick\b/.test(k.className) && k.textContent === 'my pick'), 'the pick is marked on its answer');
+    assert.ok(!all.some((k) => /\bproto-tag\b/.test(k.className)), 'no real-or-prototype tag: every card is real');
+    // a stored ask is answered on the card itself (task 1004702); only a matter without one sends you to its desk
+    assert.doesNotMatch(deck.textContent, /sent back|until its agent writes it|prototype data|pass it on/);
+    // the city's card answers its first ask in place (task 1004702), the same stored card
+    const city = await bootCity(false);
+    noPrototype(city, 'city with stored asks');
+    for (const b of BUILDINGS) {
+      city.byId.get('cityHits').children.find((h) => h.attrs['data-building'] === b).fire('click');
+      const asks = city.byId.get('cityCard').querySelectorAll('.city-ask');
+      assert.ok(asks.length <= 1, b + ': at most its first ask');
+      if (b === 'planning') assert.ok(asks.length === 1 && asks[0].querySelectorAll('.ask__opt').length === 2, 'Planning answers its stored ask in place');
+      noPrototype(city, 'city card with stored asks ' + b);
+    }
+  } finally { docketAsks = false; }
+});
+
+test('inside every building on a real site: no Lead, no office storey, no build-out, no invented law, no pot', async () => {
+  for (const b of BUILDINGS) {
+    const p = await bootStreet('#building=' + b, false);
+    const text = noPrototype(p, 'inside ' + b);
+    // task 1004715: the Charter's book is the real presets read, so it stands on a real site
+    if (b === 'charter') assert.match(text, /how strict the agents run[\s\S]*no preset yet[\s\S]*Open workshop[\s\S]*Factory/, 'the Charter shows the real presets');
+    assert.ok(!p.byId.get('insideFloors').kids.some((k) => k.getAttribute('data-floor') === 'office'), `${b}: no office storey`);
+  }
+});
+
+test('My agents on a real site: the real rows only; no laws, prototype settings or key; Make it a law and the preset strip are real', async () => {
+  const p = await bootMyAgents(false);
+  noPrototype(p, 'my agents');
+  // task 1004715: the strictness strip is GET /government/presets, so it stands on a real site
+  const strict = p.byId.get('ma-strict');
+  assert.equal('hidden' in strict.attrs, false, 'the strictness strip stands');
+  assert.match(strict.innerHTML, /No preset yet/, 'the hub has no law, so no preset is in force');
+  assert.match(strict.innerHTML, /data-preset="factory"[\s\S]*4 of \d+ lock/, 'Factory says what it would lock of your rows');
+  assert.doesNotMatch(strict.innerHTML, /data-proto/, 'and nothing on it is prototype');
+  assert.ok(p.calls.includes('/api/bongos/government/presets'), 'read from the route');
+  assert.equal(p.byId.get('ma-key'), undefined, 'no prototype key');
+  const rows = p.byId.get('ma-rows').innerHTML;
+  assert.match(rows, /data-row="technical_level"/, 'the real rows from GET /me stand');
+  for (const k of ['on_stuck', 'ask_timing', 'ask_format', 'parallel_agents', 'auto_go_live']) assert.doesNotMatch(rows, new RegExp(`data-row="${k}"`), `${k} is a prototype setting`);
+  const desk = rows.split('data-group="habits"')[0];
+  assert.doesNotMatch(desk, /law/i, 'no row is locked or capped by a law: none is in force');
+  // task 1004714: Make it a law files a real laws vote, so it stands on a real site too
+  assert.match(rows, /data-group="habits"[\s\S]*data-propose="machinery"/, 'Make it a law is offered to a builder who may open a board item');
+  assert.doesNotMatch(p.byId.get('ma-reads-body').innerHTML, /law/i, 'what the agent reads is only what it really reads');
+  assert.doesNotMatch(p.byId.get('ma-sub').textContent || p.byId.get('ma-sub')._html, /law/i, 'the subtitle names no laws');
+});
+
+test('My agents on a real site with a law in force: the law is what the agent reads first, its lock holds the row, nothing proto', async () => {
+  meLaws = ME_LAWS;
+  try {
+    const p = await bootMyAgents(false);
+    const text = noPrototype(p, 'my agents with a real law');
+    const reads = p.byId.get('ma-reads-body').innerHTML;
+    assert.ok(reads.includes(esc(A_REAL_LAW)), 'the law is in what the agent reads');
+    assert.ok(reads.indexOf(esc(A_REAL_LAW)) < reads.indexOf('Yours'), 'first, before the builder\'s own');
+    const rows = p.byId.get('ma-rows').innerHTML;
+    assert.match(rows, /data-row="verbosity"[^>]*>[\s\S]*?class="ma-lock">/, 'the verbosity row is locked, and the lock is not marked prototype');
+    assert.ok(rows.includes(esc(A_REAL_LAW) + ' · Law 1'), 'the lock names the law and its number');
+    assert.ok(text.includes('The project\'s laws come first'), 'the subtitle now says so');
+  } finally { meLaws = null; }
+});
+
+test('the seat-gated nav on a real site reads /me\'s positions: real seats, no overlay; no block is unknown, never "none"', () => {
+  const overlay = OLD_OVERLAY;
+  const constitution = fx('government__constitution');
+  // no positions block (module off, read failed): unknown, whatever the overlay or constitution say
+  for (const viewer of [{ builder: fx('me').builder }, { builder: { id: '424242', rank: 'thetes' } }]) {
+    for (const o of [overlay, null]) {
+      const p = GovPositions.positionsFor({ me: viewer, overlay: o, constitution });
+      assert.equal(p.known, false, `${viewer.builder.rank}, overlay ${o ? 'read' : 'unread'}: unknown, so nothing hides`);
+    }
+  }
+  // the server's block: known, every seat real, and the overlay changes nothing
+  const me = fx('me');
+  const p = GovPositions.positionsFor({ me, overlay: null, constitution });
+  const q = GovPositions.positionsFor({ me, overlay, constitution });
+  assert.equal(p.known, true);
+  assert.deepEqual(JSON.parse(JSON.stringify(p)), JSON.parse(JSON.stringify(q)), 'the overlay decides no seat');
+  assert.ok(p.positions.every((s) => s.source === 'real'));
+});
+
+test('a Lead the government appointed stands on their building on a real site; every unseated building shows the owner; nothing proto', async () => {
+  leadsBook = LEADS_READ;
+  try {
+    const city = await bootCity(false);
+    assert.ok(city.calls.includes('/api/bongos/government/leads'), 'the city reads who leads each building');
+    const text = noPrototype(city, 'city with real Leads', { seatsRead: true });
+    assert.ok(text.includes(A_REAL_LEAD), 'the Lead\'s name stands on their building');
+    const plates = city.byId.get('citySky').querySelectorAll('.city-plate');
+    const planningPlate = plates.find((p) => p.attrs['data-building'] === 'planning');
+    assert.ok(planningPlate && planningPlate.textContent === A_REAL_LEAD, 'Planning\'s plate names its Lead');
+    assert.ok(!('data-proto' in planningPlate.attrs), 'and the plate is real');
+    const ownerPlates = plates.filter((p) => /city-plate--owner/.test(p.className));
+    assert.equal(ownerPlates.length, 8, 'the eight unseated buildings each carry the owner\'s plate');
+    assert.ok(ownerPlates.every((p) => p.textContent === 'owner' && !('data-proto' in p.attrs)));
+    const hit = (b) => city.byId.get('cityHits').children.find((h) => h.attrs['data-building'] === b);
+    assert.match(hit('planning').attrs['aria-label'], new RegExp('led by ' + A_REAL_LEAD));
+    assert.match(hit('release').attrs['aria-label'], /held by the owner/);
+    hit('planning').fire('click');
+    assert.match(city.byId.get('cityCard').textContent, new RegExp('Led by ' + A_REAL_LEAD + '\\.'));
+    hit('treasury').fire('click');
+    assert.match(city.byId.get('cityCard').textContent, /hold(s)? it until a Lead is seated\./);
+    noPrototype(city, 'city card with real Leads', { seatsRead: true });
+    const street = await bootStreet('', false);
+    assert.ok(street.calls.includes('/api/bongos/government/leads'), 'the street reads it too');
+    noPrototype(street, 'street with real Leads', { seatsRead: true });
+    const doors = street.byId.get('streetDoors').children;
+    assert.match(doors.find((d) => d.getAttribute('data-door') === 'planning').attrs['aria-label'], new RegExp('led by ' + A_REAL_LEAD));
+    assert.match(doors.find((d) => d.getAttribute('data-door') === 'review').attrs['aria-label'], /held by the owner/);
+  } finally { leadsBook = null; }
+});
+
+test('a law the project really passed stands on a real site: the street names it, the city counts it, nothing proto', async () => {
+  lawBook = REAL_BOOK;
+  try {
+    const city = await bootCity(false);
+    assert.ok(city.calls.includes('/api/bongos/government/laws'), 'the city reads the law book');
+    noPrototype(city, 'city with a real law');
+    const plaque = city.byId.get('cityPlaque');
+    const before = fx('government__docket').readings.some((r) => r && r.key === 'rules' && r.status === 'live') ? 1 : 0;
+    const tile = plaque.kids.find((k) => k.attrs['data-key'] === 'laws');
+    assert.ok(tile, 'the plaque has a laws tile');
+    assert.equal(tile.kids[0].textContent, String(before + 1), "it counts the real law beside the docket's rule");
+    assert.ok(!('data-proto' in tile.attrs), 'and the count is real');
+    const street = await bootStreet('', false);
+    assert.ok(street.calls.includes('/api/bongos/government/laws'), 'the street reads the law book');
+    const text = noPrototype(street, 'street with a real law');
+    assert.ok(text.includes(A_REAL_LAW), 'the Rules reading names the law the project passed');
+  } finally { lawBook = null; }
+});
+
+// A Lead's build-outs (task 1004711), as GET /government/leads carries them: a floor
+// going up and a committee room built at Planning, and Release held by the owner seat
+// the viewer sits in. The names are this test's own words, so the overlay scan cannot
+// excuse them.
+const A_REAL_FLOOR = 'Quill Ledger Floor';
+const A_REAL_ROOM = 'Quill Triage Room';
+const LEADS_BUILT = (() => {
+  const r = JSON.parse(JSON.stringify(LEADS_READ));
+  r.buildings.forEach((b) => { b.structure = { standing: [], proposed: [] }; });
+  const pl = r.buildings.find((b) => b.building === 'planning');
+  pl.structure.standing = [
+    { id: '1', building: 'planning', capsule: 'floor', name: A_REAL_FLOOR, line: 'Where the next quarter is planned.', state: 'building', progress: 0.4, started_at: '2026-10-09T20:00:00.000Z', builder: null, allowed: { path: 'at_once', ground: 'form', why: 'The founder decides alone.' } },
+    { id: '2', building: 'planning', capsule: 'committee', name: A_REAL_ROOM, line: 'Sorts what comes in.', state: 'built', progress: 1, started_at: '2026-10-01T00:00:00.000Z', builder: null, allowed: { path: 'vote', item_id: '44', href: '/board-room?item=44' } },
+  ];
+  const rel = r.buildings.find((b) => b.building === 'release');
+  rel.answers = { seat: 'owner', builder_ids: [String(fx('government__docket').viewer.id)], fell_to_owner: true };
+  rel.build_rights = { form: 'monarchy', form_name: 'Monarchy / BDFL', holder: 'owner', capsules: Object.fromEntries(['committee', 'floor', 'annex', 'district'].map((c) => [c, { without_vote: c !== 'district', why: 'The founder decides alone.', ground: c === 'district' ? 'city' : 'form' }])) };
+  return r;
+})();
+
+test('a Lead\'s build-outs stand on a real site: the office storey, its floor going up and its room are real; nothing proto', async () => {
+  leadsBook = LEADS_BUILT;
+  try {
+    const p = await bootStreet('#building=planning', false);
+    const office = p.byId.get('insideFloors').kids.find((k) => k.getAttribute('data-floor') === 'office');
+    assert.ok(office, 'the office storey stands on a real site once the Leads are read');
+    const site = p.byId.get('insideFloors').kids.find((k) => /Open the build/.test(k.getAttribute('aria-label') || ''));
+    assert.ok(site && site.getAttribute('aria-label').includes(A_REAL_FLOOR), 'the floor going up is a site of its own');
+    let text = noPrototype(p, 'inside planning with real build-outs', { seatsRead: true });
+    assert.ok(text.includes(A_REAL_FLOOR), 'the floor going up is drawn');
+    office.fire('click');
+    await settle();
+    text = noPrototype(p, 'the real Lead\'s office', { seatsRead: true });
+    assert.ok(text.includes(A_REAL_ROOM), 'its committee room is a row of the office');
+    assert.ok(text.includes('40% built'), 'the floor going up says how far, from its real start');
+    assert.ok(!p.roots.some((r) => r.querySelectorAll('[data-capsule]').length), 'the viewer does not hold Planning: no build-out chips');
+    // Release is held by the owner seat the viewer sits in: the chips stand, in the server's words
+    const r = await bootStreet('#building=release', false);
+    r.byId.get('insideFloors').kids.find((k) => k.getAttribute('data-floor') === 'office').fire('click');
+    await settle();
+    noPrototype(r, 'the owner\'s office at Release', { seatsRead: true });
+    const chips = r.roots.flatMap((x) => x.querySelectorAll('[data-capsule]'));
+    assert.deepEqual(chips.map((c) => c.getAttribute('data-capsule')), ['committee', 'floor', 'annex', 'district']);
+    assert.deepEqual(chips.map((c) => c.kids[c.kids.length - 1].textContent), ['builds now', 'builds now', 'builds now', 'a vote']);
+    // a tap is the real route
+    chips[1].fire('click');
+    await settle();
+    assert.ok(r.calls.includes('/api/bongos/government/buildouts'), 'the tap posts to the server');
+  } finally { leadsBook = null; }
+});
+
+test('the treasury stands on a real site: real pots, the reserve, the cap off, the dry pot\'s borrow in place; nothing proto (task 1004712)', async () => {
+  leadsBook = LEADS_READ;
+  treasuryBook = TREASURY_READ;
+  try {
+    const p = await bootStreet('#building=treasury', false);
+    assert.ok(p.calls.includes('/api/bongos/government/treasury'), 'the street reads the treasury');
+    const text = noPrototype(p, 'inside the treasury with a real treasury', { seatsRead: true });
+    assert.ok(text.includes('of $750 · dry'), 'the real dry pot is drawn: its real spend against its budget');
+    assert.ok(text.includes('no spend limit'), 'the cap is off: no spend limit');
+    assert.ok(text.includes('in reserve'), 'the reserve is a real tile');
+    assert.ok(text.includes('Lend'), 'the dry pot\'s borrow is answered in place, in its stored words');
+    const city = await bootCity(false);
+    noPrototype(city, 'the city with a real treasury', { seatsRead: true });
+  } finally { leadsBook = null; treasuryBook = null; }
+});