@bongos/core 1.21.141 → 1.21.142

package/modules/hall-ui/public/studio-lib.js

@@ -151,6 +151,26 @@
     });
   }
 
+  // Pages in flight (task 1004662): every page with an open round, where it
+  // is and since when, from the server's own list (stuck first). The panel
+  // derives no state; it only words the age.
+  function inFlightRows(pages, now) {
+    const at = now instanceof Date ? now.getTime() : Number(now || Date.now());
+    return ((pages && pages.in_flight) || []).map((p) => {
+      const t = p.since ? Date.parse(p.since) : NaN;
+      const days = Number.isFinite(t) ? Math.max(0, Math.floor((at - t) / 86400000)) : null;
+      const age = days == null ? '' : days === 0 ? 'since today' : days === 1 ? 'for 1 day' : `for ${days} days`;
+      return {
+        page_id: p.page_id,
+        title: titleOf(p),
+        surface: surfaceWord(p.surface),
+        state: p.state_word || 'Needs a look',
+        age,
+        stuck: !!p.stuck,
+      };
+    });
+  }
+
   function askedLine(n) {
     const v = num(n);
     if (v <= 0) return '';
@@ -221,7 +241,7 @@
 
   const api = {
     STUDIO_PAGE, PAGE_ID_RE, SURFACE_WORDS, surfaceWord, titleOf, numberWords, tallyParts, resumeDetail,
-    subParts, flowDetail, statusDetail, apexHost, landingHost, surfaceRows, askedLine, pickLabel, matchLine, claimWords,
+    subParts, flowDetail, statusDetail, apexHost, landingHost, surfaceRows, inFlightRows, askedLine, pickLabel, matchLine, claimWords,
     skyAt, dayPart, STOCK_GREETING, clockGreets,
   };
   if (typeof window !== 'undefined') window.OTBStudioLib = api;

package/modules/hall-ui/public/studio.css

@@ -631,6 +631,17 @@ html.st-open { overflow: hidden; }
 .st-surface__fill { height: 4px; border-radius: 999px; background: var(--st-accent); }
 .st-asked { margin: 0; font-size: 14px; line-height: 1.5; color: var(--st-ink-faint); }
 
+/* Where your pages are (task 1004662): each page with an open round, its state
+   and how long; a stuck page leads and carries the accent. */
+.st-flight__head { margin: 28px 0 10px; font-size: 13px; font-weight: 500; letter-spacing: .04em; text-transform: uppercase; color: var(--st-ink-dim); }
+.st-flights { display: flex; flex-direction: column; gap: 4px; margin: 0; padding: 0; list-style: none; }
+.st-flight { display: flex; align-items: baseline; gap: 10px; flex-wrap: wrap; padding: 6px 0; }
+.st-flight__page { min-height: 24px; display: inline-flex; align-items: center; font-size: 15px; color: var(--st-ink); text-decoration: none; overflow-wrap: anywhere; }
+.st-flight__page:hover, .st-flight__page:focus-visible { text-decoration: underline; }
+.st-flight__where { font-size: 13px; color: var(--st-ink-dim); }
+.st-flight__state { margin-left: auto; font-size: 13.5px; color: var(--st-ink-soft); }
+.st-flight--stuck .st-flight__state { color: var(--st-accent); }
+
 /* From the live site (task 1004499): one row per review, the page then who and
    when, then its opening words. Each row opens the doc in the palette's panel. */
 .st-sites { display: flex; flex-direction: column; gap: 6px; margin: 0; padding: 0; list-style: none; }

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

@@ -720,7 +720,14 @@
         <div class="st-surface__track"><div class="st-surface__fill" style="width: ${Number(s.pct)}%"></div></div>
       </li>`).join('');
     const asked = lib.askedLine(home.next && home.next.asked_pages);
-    return `<ul class="st-surfaces">${rows}</ul>${asked ? `<p class="st-asked">${escapeHtml(asked)}</p>` : ''}`;
+    const flight = lib.inFlightRows(home.pages, new Date()).map((f) => `
+      <li class="st-flight${f.stuck ? ' st-flight--stuck' : ''}">
+        <a class="st-flight__page" href="${escapeHtml(editorHref(f.page_id))}">${escapeHtml(f.title)}</a>
+        <span class="st-flight__where">${escapeHtml(f.surface)}</span>
+        <span class="st-flight__state">${escapeHtml(f.state)}${f.age ? ` · ${escapeHtml(f.age)}` : ''}${f.stuck ? ' · stuck' : ''}</span>
+      </li>`).join('');
+    const inFlight = flight ? `<h3 class="st-flight__head">Where your pages are</h3><ul class="st-flights">${flight}</ul>` : '';
+    return `<ul class="st-surfaces">${rows}</ul>${asked ? `<p class="st-asked">${escapeHtml(asked)}</p>` : ''}${inFlight}`;
   }
 
   function siteHtml() {

package/modules/hall-ui/records/living-city.md

@@ -45,7 +45,9 @@ The city's plaque and door, the street's header and readings, the deck and the s
 
 - **Nothing is invented.** A field comes from a read or is derived from reads by a rule in `gov-living.js`; a read that fails leaves its part out. No sample data, no prototype mark, no key.
 - **Salmon is spent only on what needs you**, everywhere: a matter routed to another seat stands in ink on the street (pin and windows) as in the city. Ordinary activity is ink, and so is a choice: inside a building the chosen floor, its frame, sign and number, the lift and the desk's plate are ink, salmon only while that floor needs you (task 1004718).
-- **What needs you is never hidden.** The civic quarter's back corner, centre and front corner stand in one screen column, so the Charter (the tallest) takes the back corner and nothing taller stands in front of Planning; a building's salmon windows take its top rows first (task 1004718).
+- **What needs you is never hidden.** The civic quarter's back corner, centre and front corner stand in one screen column, so the Charter (the tallest) takes the back corner and nothing taller stands in front of Planning; a building's salmon windows take its top rows first (task 1004718). Task 1004724 holds the rule in every column: the taller of any two buildings in one screen column stands at the back (Release behind Rules, Automation behind People), tested over all nine.
+- **One ask, one place.** Inside a building, an ask the floor desk already holds as a row (the treasury's dry pot) is not repeated as a card in the building's book above it (task 1004724).
+- **Who should lead.** The Lead's office offers anyone who may open a board item a pick of the project's active people and one chip; it files the existing appoint_lead People matter (POST /government/board/matters). Only the vote passing seats a Lead; the server checks everything again (task 1004724).
 - **The street band is cropped to what it draws** (`street.js` `BAND_TOP`/`BAND_H`, matched by `street.css`): no empty sky over the skylanes and no bare ground under the brackets; a stage taller than the street needs gives its spare height to the foot of the page, under the readings, never to the sky. Paper haze is a cool sea tone deep enough to read as distance (task 1004718).
 - **Motion is CSS only**, says only "this is live", and carries no data (count, size, position and colour do). Ambient loops are 20 s or longer (the pin's halo breathes on 24 s); growth, build-out and the deck's card (the panel rises once) are class-triggered one-shots; every animation stops under `prefers-reduced-motion`, and the still frame is a complete picture.
 - **Colours are the pack's tokens**, except the iso and front-on drawing palettes, which are drawing data. Dark rules are written twice. Light mode is paper: glows become ink washes.

package/modules/ideas/governor-docket.js

@@ -22,7 +22,10 @@ const blockers = require('./blockers');
 const ratify = require('./ratify');
 
 const POINT = 'governor.docket';
-const DOCKET_BLOCKER_LIMIT = 50;
+// Every open blocker is a matter, so the docket's counts are complete (task
+// 1004724: a cap of 50 undercounted past it). Open blockers are few and the read
+// is one indexed query; this ceiling only guards a runaway table.
+const DOCKET_BLOCKER_LIMIT = 2000;
 
 // One open blocker for one viewer. The list is public (GET /blockers), so every
 // governor sees it; only a viewer who may resolve it (`blocker.review`, the

package/modules/lifecycle/criterion-uat-db.js

@@ -135,6 +135,7 @@ async function signOff({ criterionId, kind, signerId, recording = null, liveAtte
   const readings = await readLive(before.shippedIds, deps);
   const live = uat.foldLiveReadings(readings);
   const owner = deps.ownerId !== undefined ? { id: deps.ownerId } : await api.getFoundingBuilder();
+  const signerIsOwner = await holdsOwnerSeat(signerId, deps);
 
   return withTx(async (client) => {
     const { rows: crit } = await client.query(
@@ -148,7 +149,7 @@ async function signOff({ criterionId, kind, signerId, recording = null, liveAtte
     const backendOnly = criterion ? await isBackendOnly(client, id) : false;
     const refusal = uat.signoffRefusal({
       criterion, counts: now.counts, remaining: now.remaining, backendOnly, kind,
-      signerId, ownerId: owner ? owner.id : null, shipperIds: now.shipperIds,
+      signerId, ownerId: owner ? owner.id : null, signerIsOwner, shipperIds: now.shipperIds,
       recording, live, liveAttested,
     });
     if (refusal) return { ok: false, refusal };
@@ -164,6 +165,22 @@ async function signOff({ criterionId, kind, signerId, recording = null, liveAtte
   }, { pool });
 }
 
+// holdsOwnerSeat — does the signer hold the government's owner seat (task
+// 1004757)? Read per request through the government port, uncached (ADR 0016).
+// No port, or a failed read, answers false: the founding-builder check still
+// applies, so this can only ever ADD the owner, never widen past them.
+async function holdsOwnerSeat(signerId, deps = {}) {
+  const testing = process.env.NODE_ENV === 'test';
+  const government = testing && deps.government !== undefined ? deps.government : api.resolveOptional('government');
+  if (!government || typeof government.positionsFor !== 'function') return false;
+  try {
+    const p = await government.positionsFor(signerId);
+    return !!(p && Array.isArray(p.held) && p.held.some((h) => h && h.kind === 'owner'));
+  } catch {
+    return false;
+  }
+}
+
 // recordOverride — the /satisfy escape hatch, which now has to give a reason and
 // leaves a row saying so (the state reads "Satisfied (override)", never UAT).
 async function recordOverride(exec, { criterionId, signerId, reason }) {

package/modules/lifecycle/criterion-uat.js

@@ -27,6 +27,14 @@
 // solo project can never deadlock on its own work (the owner's "any other
 // builder or the owner").
 //
+// WHO IS THE OWNER (task 1004757). The government's owner seat — every active
+// Archon (modules/government/leads.js ownerOf) — is who this project calls its
+// owner everywhere else (the "Owner" position on /me, the seat an unseated
+// building falls to). The founding builder (lowest-id human) is kept as a
+// fallback for an instance without the government module. Using ONLY the
+// founding builder refused the real owner on a hub whose lowest-id human is
+// someone else, while the refusal itself told them the owner could sign.
+//
 // This file has NO database and NO express: the state derivation and the
 // refusal ladder are pure so every answer is pinned by a DB-free test, and the
 // store unit-tests against a temp dir. The SQL lives in criterion-uat-db.js.
@@ -125,12 +133,13 @@ function foldLiveReadings(readings) {
 //   backendOnly    boolean
 //   kind           'uat' | 'backend_signoff'
 //   signerId       the authenticated builder
-//   ownerId        the project owner (getFoundingBuilder), or null
+//   ownerId        the founding builder (getFoundingBuilder), or null
+//   signerIsOwner  the signer holds the government's owner seat
 //   shipperIds     builder ids that shipped a linked task
 //   recording      a stored recording name, or null
 //   live           foldLiveReadings(...) output
 //   liveAttested   the signer ticked "this is on the live site"
-function signoffRefusal({ criterion, counts, remaining = [], backendOnly, kind, signerId, ownerId = null, shipperIds = [], recording = null, live = { available: false }, liveAttested = false }) {
+function signoffRefusal({ criterion, counts, remaining = [], backendOnly, kind, signerId, ownerId = null, signerIsOwner = false, shipperIds = [], recording = null, live = { available: false }, liveAttested = false }) {
   if (!criterion) return { code: 'criterion_not_found', status: 404, message: 'No such criterion.' };
   if (criterion.satisfied) {
     return { code: 'criterion_already_satisfied', status: 409, message: 'This criterion is already closed.' };
@@ -153,7 +162,7 @@ function signoffRefusal({ criterion, counts, remaining = [], backendOnly, kind,
     return { code: 'criterion_needs_recording', status: 409, message: 'This criterion is user-facing, so it needs a UAT recording. Only a criterion marked backend-only when it was written can be signed off without one.' };
   }
   const signer = String(signerId);
-  const isOwner = ownerId != null && String(ownerId) === signer;
+  const isOwner = signerIsOwner === true || (ownerId != null && String(ownerId) === signer);
   if (!isOwner && shipperIds.map(String).includes(signer)) {
     return { code: 'signer_shipped_this_work', status: 403, message: 'You shipped work linked to this criterion, so someone else has to sign it off. Any other reviewer, or the project owner, can.' };
   }

package/modules/lifecycle/routes/project-settings.js

@@ -412,9 +412,9 @@ module.exports = function buildProjectSettingsRouter() {
   router.patch('/project-settings/spend-cap', api.requireBuilder, api.requirePermission('project.settings.manage'), api.requireActAlone('treasury'), async (req, res) => {
     if (api.validateOrRespond(req, res, { usd: {} })) return; // a number of dollars, or null to turn it off; parsed below
     const raw = req.body ? req.body.usd : undefined;
-    if (raw === undefined) return res.fail('bad_spend_cap', { status: 400, message: 'usd: send a number of dollars a month, or null to turn the cap off' });
+    if (raw === undefined) return res.fail('bad_spend_cap', { status: 400, message: 'Send a number of dollars a month, or nothing to turn the cap off.' });
     const parsed = raw === null ? { usd: null } : api.projectSettings.parseSpendCap(raw);
-    if (parsed.reason) return res.fail('bad_spend_cap', { status: 400, message: `usd: ${parsed.reason}` });
+    if (parsed.reason) return res.fail('bad_spend_cap', { status: 400, message: parsed.reason });
     try {
       await api.projectSettings.setSpendCap(parsed.usd, req.builder.id);
       const resolved = await api.projectSettings.resolveSpendCap();

package/package-lock.json

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

package/package.json

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

@@ -9844,9 +9844,23 @@
     }
   ],
   "1.21.141": [
+    {
+      "id": "1004757",
+      "text": "The project owner can now sign off a goal criterion even when they built some of its work, as the on-screen message always said. Everyone else who built the work still needs someone else to sign."
+    },
+    {
+      "id": "1004662",
+      "text": "The Studio now shows where every page you have submitted actually is: waiting to be applied, being applied, waiting for your review, or approved and going live, with how long it has sat there and a \"stuck\" mark when it has sat"
+    },
     {
       "id": "1004755",
       "text": "Your home page now lists only the goals you have joined that are still open, and under each one says how many tasks you can pick up. Finished goals no longer crowd them out."
     }
+  ],
+  "1.21.142": [
+    {
+      "id": "1004724",
+      "text": "Twelve small government fixes. Spend-cap mistakes now read as plain sentences. Removing a Lead from a building with none says what to do next. A toast names a setting by its name, not its code. Inside the Treasury, the dry-pot"
+    }
   ]
 }

package/src/bongos/project-settings.js

@@ -358,11 +358,12 @@ function describeTweakAutopickup(resolved) {
 // it is said so and a new loan is recommended against. It never stops work.
 const MAX_SPEND_CAP_USD = 1000000;
 function parseSpendCap(raw) {
-  if (raw == null || raw === '') return { reason: 'empty' };
+  // The reasons are plain sentences a person reads as-is (task 1004724).
+  if (raw == null || raw === '') return { reason: 'Type a number of dollars a month, or clear the cap to turn it off.' };
   const n = Number(raw);
-  if (!Number.isFinite(n)) return { reason: 'not a number' };
-  if (n <= 0) return { reason: 'must be more than $0; clear the cap to turn it off' };
-  if (n > MAX_SPEND_CAP_USD) return { reason: `out of range (1..${MAX_SPEND_CAP_USD})` };
+  if (!Number.isFinite(n)) return { reason: 'That is not a number. Type a number of dollars a month, like 200.' };
+  if (n <= 0) return { reason: 'The cap must be more than $0. To have no cap, clear it instead.' };
+  if (n > MAX_SPEND_CAP_USD) return { reason: `The cap can be at most $${MAX_SPEND_CAP_USD.toLocaleString('en-US')} a month.` };
   return { usd: Math.round(n * 100) / 100 };
 }
 // resolveSpendCap() — { on, usd, source, invalid }. Off (usd null) unless a usable

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.141'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.142'; // 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/criterion_uat.mjs

@@ -238,6 +238,48 @@ await test('SIGNOFF: a shipper is refused and NOTHING is written', async () => {
   assert.ok(!db.calls.some((c) => /WITH candidate AS/.test(c.sql)), 'a refusal never runs the close');
 });
 
+// task 1004757: the owner the refusal names is the government's owner seat. The
+// hub's owner was refused because only the founding builder (lowest-id human)
+// counted, and on the hub that is someone else.
+const ownerSeat = (ids) => ({ positionsFor: async (id) => ({ held: ids.includes(String(id)) ? [{ kind: 'owner' }] : [{ kind: 'board' }] }) });
+
+await test('LADDER: the owner seat may sign off work they shipped, even when not the founding builder', () => {
+  assert.equal(code({ signerId: 7, ownerId: 3, signerIsOwner: true }), null);
+  assert.equal(code({ signerId: 7, ownerId: 3, signerIsOwner: false }), 'signer_shipped_this_work');
+});
+
+await test('SIGNOFF: a shipper holding the owner seat is allowed and the row is written', async () => {
+  const db = signoffDb({ linked: SHIPPED });
+  const out = await uatDb.signOff(
+    { criterionId: 5, kind: 'uat', signerId: 7, recording: REC, liveAttested: true },
+    { pool: db, withTx: withTx(db), deployPort: null, ownerId: 3, government: ownerSeat(['7']) },
+  );
+  assert.equal(out.ok, true, JSON.stringify(out.refusal));
+  assert.equal(inserts(db).length, 1);
+});
+
+await test('SIGNOFF: a shipper on the board but NOT the owner seat is still refused', async () => {
+  const db = signoffDb({ linked: SHIPPED });
+  const out = await uatDb.signOff(
+    { criterionId: 5, kind: 'uat', signerId: 7, recording: REC, liveAttested: true },
+    { pool: db, withTx: withTx(db), deployPort: null, ownerId: 3, government: ownerSeat(['9']) },
+  );
+  assert.equal(out.ok, false);
+  assert.equal(out.refusal.code, 'signer_shipped_this_work');
+  assert.equal(inserts(db).length, 0);
+});
+
+await test('SIGNOFF: an unreadable owner seat falls back to the founding builder, never wider', async () => {
+  const broken = { positionsFor: async () => { throw new Error('down'); } };
+  const db = signoffDb({ linked: SHIPPED });
+  const out = await uatDb.signOff(
+    { criterionId: 5, kind: 'uat', signerId: 7, recording: REC, liveAttested: true },
+    { pool: db, withTx: withTx(db), deployPort: null, ownerId: 3, government: broken },
+  );
+  assert.equal(out.ok, false);
+  assert.equal(out.refusal.code, 'signer_shipped_this_work');
+});
+
 await test('SIGNOFF: the project owner may sign off their own shipped work', async () => {
   const db = signoffDb({ linked: [{ id: 11, status: 'shipped', shipped_by: 3, shipped_at: new Date() }] });
   const out = await uatDb.signOff(

package/tests/government_tidy_up.mjs

@@ -0,0 +1,223 @@
+// tests/government_tidy_up.mjs — the government tidy-up after the goal 1000111
+// chain (task 1004724). One case per item that changed behaviour; DB-free (every
+// read is stubbed at the module seam it goes through).
+//
+//   1  the spend-cap refusals are plain sentences, sent as-is
+//   2  "no Lead to remove" says what to do next
+//   3  a setting a law already holds is named by its row name, not its key
+//   5  /settings shows the law locks its reads report (settings-law-locks.js)
+//   7  in every city column the taller building stands at the back
+//   8  the city plaque's words are in the body face in both modes
+//   9  the docket reads every open blocker, so its counts are complete
+//  10  the office offers "who should lead", filed as the appoint_lead People matter
+//  11  a habit already up for a vote reads "proposed" after a reload
+//  12  two appointments racing to one unseated building: a clean refusal
+//   4  the treasury's dry-pot ask shows once: the book's card steps aside for the desk row
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+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 HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const projectSettings = require(path.join(ROOT, 'src', 'bongos', 'project-settings.js'));
+const govDb = require(path.join(ROOT, 'modules', 'government', 'db.js'));
+const board = require(path.join(ROOT, 'modules', 'government', 'board.js'));
+const decisionBoard = require(path.join(ROOT, 'modules', 'government', 'decision-board.js'));
+const ideasBlockers = require(path.join(ROOT, 'modules', 'ideas', 'blockers.js'));
+const ideasDocket = require(path.join(ROOT, 'modules', 'ideas', 'governor-docket.js'));
+const City = require(path.join(HALL, 'city-draw.js'));
+const MyAgents = require(path.join(HALL, 'my-agents.js'));
+const Laws = require(path.join(HALL, 'settings-law-locks.js'));
+const Office = require(path.join(HALL, 'street-office.js'));
+
+async function withStubs(target, stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = target[k]; target[k] = v; }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) target[k] = v; }
+}
+
+test('1: every spend-cap refusal is a plain sentence, and the route sends it as-is', () => {
+  for (const raw of ['', 'lots', 0, -5, projectSettings.MAX_SPEND_CAP_USD + 1]) {
+    const { reason } = projectSettings.parseSpendCap(raw);
+    assert.ok(reason, 'refused: ' + raw);
+    assert.match(reason, /^[A-Z].*\.$/, 'a sentence: ' + reason);
+    assert.doesNotMatch(reason, /usd|\.\.|^empty$|out of range/i, 'no code words: ' + reason);
+  }
+  assert.equal(projectSettings.parseSpendCap(200).usd, 200);
+  const route = read('modules', 'lifecycle', 'routes', 'project-settings.js');
+  assert.match(route, /res\.fail\('bad_spend_cap', \{ status: 400, message: parsed\.reason \}\)/);
+  assert.doesNotMatch(route, /message: `usd: /);
+});
+
+test('2: removing a Lead from a building with none says what to do next', async () => {
+  await withStubs(govDb, {
+    listDecisionRules: async () => [], listLeads: async () => [],
+    createMatter: async () => { throw new Error('nothing is filed'); },
+    openBoardItem: async () => { throw new Error('nothing is opened'); },
+  }, async () => {
+    const out = await board.openMatter({ area: 'people', title: 'No Lead', action: { type: 'remove_lead', building: 'review' }, proposedBy: '42' });
+    assert.equal(out.reason, 'no_lead');
+    assert.match(out.what_this_means, /has no Lead to remove/);
+    assert.match(out.what_this_means, /propose a Lead/, 'the next step is named');
+  });
+});
+
+test('3: a setting a law already holds is named by its row name in the toast', () => {
+  const src = read('modules', 'hall-ui', 'public', 'my-agents.js');
+  assert.match(src, /nameFor\(str\(err\.details\.setting\)\)/);
+  assert.doesNotMatch(src, /already holds ' \+ str\(err\.details/, 'never the raw key');
+  assert.equal(MyAgents.SETTING.verbosity.name, 'Reply length');
+});
+
+test('5: a law lock on /settings disables what it rules out and names the law', () => {
+  const data = { law_locks: [
+    { setting: 'verbosity', value: 'concise', law_no: 2, law_text: 'Agents keep replies short', enforced: true, allowed: ['concise'] },
+    { setting: 'wandering', max: 'focused', law_no: 3, law_text: 'Agents stay on task', enforced: true, allowed: ['locked', 'focused'] },
+    { setting: 'machinery', value: 'nonsense', law_no: 4, enforced: false, reason: 'value_not_allowed' },
+  ] };
+  const fixed = Laws.lockFor(data, 'verbosity');
+  assert.equal(Laws.allows(fixed, 'concise'), true);
+  assert.equal(Laws.allows(fixed, 'detailed'), false);
+  assert.equal(Laws.lawLine(fixed), 'Law 2 sets this for every agent in the project: "Agents keep replies short". Only a vote can change it.');
+  const cap = Laws.lockFor(data, 'wandering');
+  assert.deepEqual(['locked', 'focused', 'balanced', 'exploratory'].map((v) => Laws.allows(cap, v)), [true, true, false, false]);
+  assert.match(Laws.lawLine(cap), /^Law 3 caps this/);
+  assert.equal(Laws.tagFor(cap), 'set by law 3');
+  assert.equal(Laws.lockFor(data, 'machinery'), null, 'a lock that enforces nothing locks nothing');
+  assert.equal(Laws.lockFor({}, 'verbosity'), null);
+  assert.equal(Laws.allows(null, 'anything'), true);
+  // both panels read it, and the page loads it before either
+  assert.match(read('modules', 'hall-ui', 'public', 'settings-interaction.js'), /Laws\.lockFor\(data, f\.field\)/);
+  assert.match(read('modules', 'hall-ui', 'public', 'settings.js'), /Laws\.lockFor\(data, 'wandering'\)/);
+  const html = read('modules', 'hall-ui', 'public', 'settings.html');
+  const at = (s) => html.indexOf(s);
+  assert.ok(at('settings-law-locks.js') > 0 && at('settings-law-locks.js') < at('/builders/settings.js') && at('settings-law-locks.js') < at('settings-interaction.js'));
+});
+
+test('7: in every screen column of the civic quarter the taller building stands at the back', () => {
+  const at = City.CIVIC_SLOTS.map(([key, x, y]) => ({ key, col: x - y, depth: x + y, roof: City.ROOF[key] }));
+  for (const b of at) {
+    for (const o of at.filter((z) => z.col === b.col && z.depth > b.depth)) {
+      assert.ok(o.roof < b.roof, o.key + ' stands in front of the shorter ' + b.key);
+    }
+  }
+  assert.equal(new Set(City.CIVIC_SLOTS.map((s) => s[0])).size, 9, 'nine buildings');
+  assert.equal(new Set(City.CIVIC_SLOTS.map((s) => s[1] + ',' + s[2])).size, 9, 'nine lots');
+});
+
+test('8: the plaque words are in the body face (the light hall maps labels to mono)', () => {
+  const css = read('modules', 'hall-ui', 'public', 'city.css');
+  assert.match(css, /\.city-plaque__words \{ font-family: var\(--font-body\);/);
+});
+
+test('9: the docket reads every open blocker, so its counts are complete past 50', async () => {
+  const many = Array.from({ length: 120 }, (_, i) => ({ id: String(i + 1), title: 'Blocker ' + (i + 1), body_md: '', status: 'open', created_at: '2026-10-01T00:00:00.000Z', blocking_task_ids: [] }));
+  let asked = null;
+  seams._reset();
+  try {
+    await withStubs(ideasBlockers, { listOpenBlockers: async (o) => { asked = o; return many.slice(0, o && o.limit != null ? o.limit : many.length); } }, async () => {
+      ideasDocket.contributeIdeasToDocket();
+      const c = seams.contributions('governor.docket').find((x) => x.source === 'blockers');
+      const rows = await c.read({ has: () => true });
+      assert.equal(rows.length, 120, 'all of them');
+      assert.ok(asked.limit == null || asked.limit >= 1000, 'a ceiling far past any real list');
+    });
+  } finally { seams._reset(); }
+});
+
+test('10: the office offers who should lead to a builder who may open a board item, filed as appoint_lead', () => {
+  const living = { seats_real: true, owner: { name: 'Builder 1' }, buildings: [
+    { key: 'treasury', name: 'Treasury', lead: { id: '7', name: 'Gus', since: '2026-10-01' }, structure: null, construction: [], answers: { ids: ['7'] } },
+  ] };
+  const roster = { builders: [
+    { id: '9', display_name: 'Zoe', status: 'active' }, { id: '7', display_name: 'Gus', status: 'active' },
+    { id: '3', github_login: 'ann', status: 'active' }, { id: '4', display_name: 'Old', status: 'inactive' },
+  ] };
+  const may = { permissions: { 'board.item.open': true } };
+  assert.equal(Office.appointPlan(living, 'treasury', roster, { permissions: {} }), null, 'not offered without the perm');
+  assert.equal(Office.appointPlan(living, 'treasury', roster, null), null);
+  const plan = Office.appointPlan(living, 'treasury', roster, may);
+  assert.deepEqual(plan.people.map((p) => p.name), ['ann', 'Zoe'], 'active people, A to Z, never the Lead in office');
+  assert.equal(plan.seated, true);
+  const body = Office.appointBody(plan, '9');
+  assert.deepEqual(body, { area: 'people', title: 'Appoint Zoe as Lead of Treasury', action: { type: 'appoint_lead', building: 'treasury', builder_id: 9 } });
+  assert.equal(decisionBoard.validateMatterAction('people', body.action).ok, true, 'the server\'s own shape');
+  assert.equal(Office.appointBody(plan, '7'), null, 'only someone on the list');
+  assert.equal(Office.appointPlan(living, 'treasury', roster, may, { leadFiled: { treasury: true } }).filed, true);
+});
+
+test('11: a habit already up for a vote reads proposed after a reload', () => {
+  const room = { open: [
+    { id: '55', subject_type: 'constitutional_amendment', subject: { kind: 'laws', proposed: { enact: [{ text: 'Agents reply in detail', locks: [{ setting: 'verbosity', value: 'detailed' }] }] } } },
+    { id: '56', subject_type: 'constitutional_amendment', subject: { kind: 'board', proposed: { enact: [{ locks: [{ setting: 'machinery', value: 'quiet' }] }] } } },
+  ] };
+  const pending = MyAgents.pendingLaws(room);
+  assert.deepEqual(pending, { 'verbosity=detailed': '55' }, 'only laws sittings');
+  assert.deepEqual(MyAgents.pendingLaws(null), {});
+  assert.deepEqual(MyAgents.pendingLaws(false), {}, 'a 403 reads as none');
+  const me = {
+    builder: { id: '1' }, permissions: { 'board.item.open': true },
+    interaction: { fields: [{ field: 'verbosity', default_value: 'concise' }, { field: 'machinery', default_value: 'show' }], stored: { verbosity: 'detailed', machinery: 'quiet' }, effective: {} },
+  };
+  const v = MyAgents.buildView({ me, pending, proposed: {} }, {});
+  const h = (k) => v.habits.find((x) => x.key === k);
+  assert.equal(h('verbosity').proposed, true);
+  assert.equal(h('verbosity').item, '55');
+  assert.equal(h('machinery').proposed, false);
+  // a vote for ANOTHER value of the same setting is not this habit
+  const other = MyAgents.buildView({ me, pending: { 'verbosity=concise': '57' }, proposed: {} }, {});
+  assert.equal(other.habits.find((x) => x.key === 'verbosity').proposed, false);
+});
+
+test('12: two appointments racing to an unseated building end in a clean refusal, not a DB error', async () => {
+  const fake = (insertError) => ({
+    query: async (sql) => {
+      if (/^\s*INSERT INTO government_leads/.test(sql)) throw insertError;
+      if (/^\s*SELECT/.test(sql)) return { rows: [] };
+      return { rows: [] };
+    },
+    release: () => {},
+  });
+  const unique = Object.assign(new Error('duplicate key value violates unique constraint "government_leads_in_office_uniq"'), { code: '23505', constraint: 'government_leads_in_office_uniq' });
+  await withStubs(api.pool, { connect: async () => fake(unique) }, async () => {
+    const out = await govDb.applyLeadAct({ itemId: '40', action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'x' } });
+    assert.equal(out.done, false);
+    assert.equal(out.reason, 'lead_seated_meanwhile');
+    assert.doesNotMatch(out.what_this_means, /duplicate|constraint|23505/);
+  });
+  const other = Object.assign(new Error('boom'), { code: '23503' });
+  await withStubs(api.pool, { connect: async () => fake(other) }, async () => {
+    await assert.rejects(govDb.applyLeadAct({ itemId: '40', action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'x' } }), /boom/, 'any other failure still throws');
+  });
+});
+
+test('4: a book card steps aside when the floor desk below holds the same matter', () => {
+  const node = (attrs, kids = []) => {
+    const n = { attrs, kids, parentNode: null, getAttribute: (k) => (k in attrs ? attrs[k] : null) };
+    kids.forEach((k) => { k.parentNode = n; });
+    n.removeChild = (c) => { n.kids = n.kids.filter((x) => x !== c); c.parentNode = null; };
+    return n;
+  };
+  const all = (n) => n.kids.flatMap((k) => [k, ...all(k)]);
+  const card1 = node({ 'data-ask': 'treasury_spending:1' });
+  const card2 = node({ 'data-ask': 'blockers:9' });
+  const book = node({}, [card1, card2]);
+  const govt = node({}, [book]);
+  govt.querySelectorAll = (sel) => (sel === '[data-ask]' ? all(govt).filter((n) => n.attrs['data-ask']) : []);
+  const desk = node({}, [node({ 'data-row': 'treasury_spending:1' })]);
+  desk.querySelector = (sel) => { const m = /^\[data-row="(.*)"\]$/.exec(sel); return m ? all(desk).find((n) => n.attrs['data-row'] === m[1]) || null : null; };
+  assert.equal(Office.page.settle(govt, desk), 1);
+  assert.deepEqual(book.kids.map((k) => k.attrs['data-ask']), ['blockers:9'], 'the one the desk shows is gone; the other stays');
+  assert.equal(Office.page.settle(null, desk), 0);
+  // street.js settles the book after it fills the floor desk
+  assert.match(read('modules', 'hall-ui', 'public', 'street.js'), /fillDesk\(on, bv\); if \(OP && OP\.settle\) OP\.settle\(\$\('insideGovt'\), on\);/);
+});

package/tests/hall_studio_home.mjs

@@ -248,6 +248,23 @@ try {
     assert.equal(lib.askedLine(0), '');
   });
 
+  await test('Where your pages are (task 1004662): the server in-flight list, worded, stuck first, with how long', () => {
+    assert.deepEqual(lib.inFlightRows(PAGES, NOW).map((r) => [r.page_id, r.state, r.age, r.stuck]), [
+      ['landing:index', 'Being written', '', false],
+    ], 'the open round the ledger holds, no date on it so no age');
+    const rows = lib.inFlightRows({ in_flight: [
+      { page_id: 'landing:contact', title: 'Contact', surface: 'landing', state_word: 'Approved, going live', since: day(17), stuck: true },
+      { page_id: 'builders:work', title: 'Tasks', surface: 'builders', state_word: 'Submitted, waiting to be applied', since: day(1), stuck: false },
+      { page_id: 'status:index', title: 'Status', surface: 'status', state_word: null, since: NOW.toISOString(), stuck: true },
+    ] }, NOW);
+    assert.deepEqual(rows.map((r) => [r.title, r.state, r.age, r.stuck]), [
+      ['Contact', 'Approved, going live', 'for 17 days', true],
+      ['Tasks', 'Submitted, waiting to be applied', 'for 1 day', false],
+      ['Status', 'Needs a look', 'since today', true],
+    ]);
+    assert.deepEqual(lib.inFlightRows(null, NOW), []);
+  });
+
   await test('a word on the page finds its own line: the most specific wins, holes alone never match, shared never', () => {
     const sentence = 'Home, on the landing page, is where you left it. Twelve of its thirty-eight lines are yours so far.';
     assert.equal(lib.matchLine(sentence, STUDIO_READING.lines).key, 'L0003', 'not the generic "{…} of {…}"');
@@ -335,6 +352,9 @@ try {
     assert.match(body, /1 of 2 tweaked/);
     assert.match(body, /style="width: 50%"/);
     assert.match(body, /1 page has been asked for/);
+    assert.match(body, /Where your pages are/);
+    assert.match(body, /st-flight__state">Being written</, 'the open round shows where it is');
+    assert.match(body, /href="\/builders\/tweak-editor\?page=landing:index"/);
     await s.clickIn('st-panel', '[data-close-panel]');
     assert.equal(s.el('st-panel').hidden, true);
     assert.ok(!s.html.classList.contains('st-open'));