@bongos/core 1.21.19 → 1.21.20

package/modules/lifecycle/governor-docket.js

@@ -123,7 +123,192 @@ function promisesReading(criteria) {
   return { value: { kept, total }, figure: `${kept} of ${total} kept`, line: 'what the goals say they deliver', hot: false };
 }
 
+// ── floors and the record (task 1004527) ─────────────────────────────────────
+// Each is pure over rows the existing reads already return; the registration
+// below gives each the atom of the route that serves those rows (GET /goals,
+// GET /versions, GET /tasks and GET /public/recent-shipped are any builder's).
+
+const MAX_LINES = 4;
+const SHIPPED_LIMIT = 200;
+const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+function monthStart(now) { const d = new Date(now); return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1); }
+function dayWord(at) { const d = new Date(at); return Number.isNaN(d.getTime()) ? '' : `${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()}`; }
+function plural(n, one, many) { return `${n} ${n === 1 ? one : many}`; }
+function more(lines, total) { if (total > lines.length) lines.push([`and ${total - lines.length} more`, '']); return lines; }
+
+// Planning · Goals: each open goal with its promises kept of total.
+function goalsFloor(goals, criteria) {
+  const open = (goals || []).filter((g) => g.status === 'open');
+  const by = new Map();
+  for (const c of criteria || []) {
+    if (c.goal_id == null) continue;
+    const k = String(c.goal_id);
+    if (!by.has(k)) by.set(k, { kept: 0, total: 0 });
+    const e = by.get(k); e.total += 1; if (c.satisfied === true) e.kept += 1;
+  }
+  const lines = open.slice(0, MAX_LINES).map((g) => {
+    const e = by.get(String(g.id));
+    return [String(g.title), e ? `${e.kept} of ${e.total} kept` : 'no promises yet'];
+  });
+  return { count: String(open.length), line: open.length ? plural(open.length, 'goal open', 'goals open') : 'no goal open', lines: more(lines, open.length), hot: false };
+}
+
+// Planning · Priorities: the building version's open goals in their worked order.
+function prioritiesFloor(goals, versionId) {
+  const mine = (goals || []).filter((g) => g.status === 'open' && (!versionId || g.version_id === versionId));
+  if (!mine.length) return { count: '', line: 'no goal in the order yet', lines: [['No open goal is ordered in the version building now.', '']], hot: false };
+  const top = mine.slice(0, 3).map((g, i) => `${i + 1} ${g.title}`).join(' · ');
+  return { count: '', line: 'the order goals are worked in', lines: [[top, versionId ? `version ${versionId}` : ''], [`${plural(mine.length, 'goal is', 'goals are')} in the order.`, '']], hot: false };
+}
+
+// Planning · Versions: what is building, and the last that shipped.
+function versionsFloor(versions, goals) {
+  const all = versions || [];
+  const building = all.filter((v) => v.status === 'building');
+  const shipped = all.filter((v) => v.status === 'shipped' && v.shipped_at).sort((a, b) => Date.parse(b.shipped_at) - Date.parse(a.shipped_at));
+  const goalsIn = (id) => (goals || []).filter((g) => g.version_id === id && g.status !== 'archived').length;
+  const lines = building.slice(0, MAX_LINES).map((v) => [`${v.name || v.id} is building.`, plural(goalsIn(v.id), 'goal', 'goals')]);
+  if (shipped[0]) lines.push([`${shipped[0].name || shipped[0].id} shipped.`, dayWord(shipped[0].shipped_at)]);
+  const head = building[0];
+  return {
+    count: '',
+    line: head ? `${head.name || head.id} building · ${plural(goalsIn(head.id), 'goal', 'goals')} in it` : 'no version building',
+    lines: lines.length ? lines : [['No version is recorded yet.', '']],
+    hot: false,
+  };
+}
+
+// Review · Signed off: promises a tester has marked kept, newest first.
+function signedOffFloor(criteria, now) {
+  const done = (criteria || []).filter((c) => c.satisfied === true && c.checked_at).sort((a, b) => Date.parse(b.checked_at) - Date.parse(a.checked_at));
+  const month = done.filter((c) => Date.parse(c.checked_at) >= monthStart(now)).length;
+  return {
+    count: String(month),
+    line: done.length ? `${month} signed off this month` : 'nothing signed off yet',
+    lines: done.slice(0, MAX_LINES).map((c) => [String(c.criterion_md), dayWord(c.checked_at)]),
+    hot: false,
+  };
+}
+
+// Release · Live this month: shipped work, newest first.
+function liveMonthFloor(shipped, now) {
+  const month = (shipped || []).filter((t) => t.shipped_at && Date.parse(t.shipped_at) >= monthStart(now));
+  return {
+    count: String(month.length),
+    line: month.length ? `${plural(month.length, 'piece', 'pieces')} of work went live` : 'nothing went live yet this month',
+    lines: more(month.slice(0, MAX_LINES).map((t) => [String(t.title), dayWord(t.shipped_at)]), month.length),
+    hot: false,
+  };
+}
+
+// Release · Held back: approved work that cannot go live until it catches up.
+function heldBackFloor(confirmed) {
+  const held = (confirmed || []).filter((t) => t.needs_rebase === true);
+  return {
+    count: String(held.length),
+    line: held.length ? `${plural(held.length, 'piece', 'pieces')} held` : 'nothing held',
+    lines: more(held.slice(0, MAX_LINES).map((t) => [String(t.title), 'must catch up first']), held.length),
+    hot: false,
+  };
+}
+
+// People · Newcomers: newcomer tasks being built, and the ones waiting.
+function newcomersFloor(active, ready) {
+  const building = (active || []).filter((t) => t.newcomer_friendly === true);
+  const waiting = (ready || []).filter((t) => t.newcomer_friendly === true);
+  return {
+    count: String(building.length),
+    line: `${plural(building.length, 'newcomer task', 'newcomer tasks')} being built`,
+    lines: [...building.slice(0, MAX_LINES - 1).map((t) => [String(t.title), 'being built']), [`${plural(waiting.length, 'newcomer task is', 'newcomer tasks are')} ready to claim.`, '']],
+    hot: false,
+  };
+}
+
+// The record: sign-offs, releases, goals achieved. Pure.
+function signoffHistory(criteria) {
+  return (criteria || []).filter((c) => c.satisfied === true && c.checked_at)
+    .map((c) => ({ id: c.id, title: String(c.criterion_md), at: c.checked_at, outcome: 'signed off' }));
+}
+function releaseHistory(shipped) {
+  return (shipped || []).filter((t) => t.shipped_at).map((t) => ({ id: t.id, title: String(t.title), at: t.shipped_at, outcome: 'live' }));
+}
+function goalHistory(goals) {
+  return (goals || []).filter((g) => g.status === 'achieved' && g.updated_at)
+    .map((g) => ({ id: g.id, title: `${g.title} achieved`, at: g.updated_at, outcome: 'all promises kept' }));
+}
+
+// The criteria of the versions the open goals live in — one read per version,
+// bounded, through the same listCriteria the version page serves.
+async function criteriaFor(versionIds) {
+  const ids = [...new Set(versionIds.filter(Boolean))].slice(0, 6);
+  return (await Promise.all(ids.map((v) => doneWhen.listCriteria(v)))).flat();
+}
+
+// One read per docket request: the collector hands every read a per-request
+// `once(key, fn)` (docket.js buildDocket), so two floors that need the same rows
+// share one query. Without it (a direct call) the read simply runs.
+const shared = (once, key, fn) => (typeof once === 'function' ? once(key, fn) : fn());
+const openGoals = (once) => shared(once, 'lifecycle.openGoals', () => db.listGoals({ status: 'open' }));
+const confirmedTasks = (once) => shared(once, 'lifecycle.confirmedTasks', () => db.listTasks({ status: 'confirmed', limit: STUCK_LIMIT }));
+
+function contributeLifecycleFloors() {
+  const any = { anyBuilder: true };
+  api.contribute(POINT, {
+    floor: 'planning.goals', gate: any,
+    read: async (_ctx, { once } = {}) => {
+      const goals = await openGoals(once);
+      return goalsFloor(goals, await criteriaFor(goals.map((g) => g.version_id)));
+    },
+  });
+  api.contribute(POINT, {
+    floor: 'planning.priorities', gate: any,
+    read: async (_ctx, { once } = {}) => prioritiesFloor(await openGoals(once), await db.currentBuildingVersionId()),
+  });
+  api.contribute(POINT, {
+    floor: 'planning.versions', gate: any,
+    read: async () => versionsFloor(await db.listVersions(), await db.listGoals({})),
+  });
+  api.contribute(POINT, {
+    floor: 'review.signed_off', gate: any,
+    read: async (_ctx, { now } = {}) => {
+      const v = await db.currentBuildingVersionId();
+      return signedOffFloor(v ? await doneWhen.listCriteria(v) : [], now);
+    },
+  });
+  api.contribute(POINT, {
+    floor: 'release.live_month', gate: any,
+    read: async (_ctx, { now } = {}) => liveMonthFloor(await db.recentShippedTasks(SHIPPED_LIMIT, { days: 31 }), now),
+  });
+  api.contribute(POINT, {
+    floor: 'release.held_back', gate: any,
+    read: async (_ctx, { once } = {}) => heldBackFloor(await confirmedTasks(once)),
+  });
+  api.contribute(POINT, {
+    floor: 'people.newcomers', gate: any,
+    read: async () => {
+      const [active, ready] = await Promise.all([db.listTasks({ status: 'active', limit: STUCK_LIMIT }), db.listTasks({ status: 'ready', limit: 200 })]);
+      return newcomersFloor(active, ready);
+    },
+  });
+  api.contribute(POINT, {
+    history: 'signoffs', building: 'review', gate: any,
+    read: async () => {
+      const v = await db.currentBuildingVersionId();
+      return signoffHistory(v ? await doneWhen.listCriteria(v) : []);
+    },
+  });
+  api.contribute(POINT, {
+    history: 'releases', building: 'release', gate: any,
+    read: async () => releaseHistory(await db.recentShippedTasks(60, { days: 120 })),
+  });
+  api.contribute(POINT, {
+    history: 'goals', building: 'planning', gate: any,
+    read: async () => goalHistory(await db.listGoals({ status: 'achieved' })),
+  });
+}
+
 function contributeLifecycleToDocket() {
+  contributeLifecycleFloors();
   api.contribute(POINT, {
     source: 'override_requests',
     building: 'release',
@@ -162,10 +347,10 @@ function contributeLifecycleToDocket() {
   api.contribute(POINT, {
     reading: 'flow',
     gate: { anyBuilder: true },
-    read: async (_ctx, { now } = {}) => {
+    read: async (_ctx, { now, once } = {}) => {
       const [completed, confirmed] = await Promise.all([
         db.listTasks({ status: 'completed', limit: STUCK_LIMIT }),
-        db.listTasks({ status: 'confirmed', limit: STUCK_LIMIT }),
+        confirmedTasks(once),
       ]);
       return flowReading({ completed, confirmed }, now);
     },
@@ -189,4 +374,14 @@ module.exports = {
   joinRequestMatter,
   flowReading,
   promisesReading,
+  goalsFloor,
+  prioritiesFloor,
+  versionsFloor,
+  signedOffFloor,
+  liveMonthFloor,
+  heldBackFloor,
+  newcomersFloor,
+  signoffHistory,
+  releaseHistory,
+  goalHistory,
 };

package/modules/security/routes/reports.js

@@ -69,6 +69,21 @@ function contributeReportsToDocket() {
       return lists.flat().map(redteamDocketMatter);
     },
   });
+  // The Disputes record (task 1004527): every report that was ruled on, dated by
+  // its ruling (confirmed or fixed). Same atom as the list route it reads.
+  api.contribute('governor.docket', {
+    history: 'rulings',
+    building: 'disputes',
+    gate: { permission: 'security.report.adjudicate' },
+    read: async () => rulingHistory((await Promise.all(['confirmed', 'fixed'].map((status) => security.listVulnerabilityReports({ scope: 'all', status, limit: 60 })))).flat()),
+  });
+}
+
+const RULING_WORDS = Object.freeze({ confirmed: 'confirmed', fixed: 'fixed', disputed: 'disputed', wontfix: 'will not fix' });
+function rulingHistory(reports) {
+  return (reports || [])
+    .filter((r) => RULING_WORDS[r.status] && (r.fixed_at || r.confirmed_at))
+    .map((r) => ({ id: r.id, title: `Security report: ${r.title}`, at: r.fixed_at || r.confirmed_at, outcome: RULING_WORDS[r.status] }));
 }
 
 module.exports = function buildSecurityReportsRouter() {
@@ -302,3 +317,4 @@ module.exports = function buildSecurityReportsRouter() {
 };
 
 module.exports.redteamDocketMatter = redteamDocketMatter;
+module.exports.rulingHistory = rulingHistory;

package/modules/security/security.js

@@ -155,7 +155,7 @@ async function createVulnerabilityReport({
 //
 // `scope: 'own'` REQUIRES builderId; omitting it throws rather than silently
 // leaking every report. Optional `status` narrows either scope.
-async function listVulnerabilityReports({ scope = 'own', builderId = null, status = null } = {}) {
+async function listVulnerabilityReports({ scope = 'own', builderId = null, status = null, limit = null } = {}) {
   if (scope !== 'own' && scope !== 'all') {
     throw { code: 'INVALID_SCOPE', scope, allowed: ['own', 'all'] };
   }
@@ -176,7 +176,10 @@ async function listVulnerabilityReports({ scope = 'own', builderId = null, statu
     `SELECT ${VULN_COLUMNS} FROM vulnerability_reports` +
     (where.length ? ` WHERE ${where.join(' AND ')}` : '') +
     ` ORDER BY reported_at DESC, id DESC`;
-  const { rows } = await pool.query(sql, params);
+  // Bounded when the caller asks (the governor docket's record, task 1004527).
+  let tail = '';
+  if (Number.isInteger(limit) && limit > 0) { params.push(limit); tail = ` LIMIT $${params.length}`; }
+  const { rows } = await pool.query(sql + tail, params);
   return rows;
 }
 

package/package-lock.json

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

package/package.json

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

@@ -8870,5 +8870,11 @@
       "id": "1004530",
       "text": "Inside any building on the street, \"change how this works\" now drafts a real amendment. It shows how the building decides today crossed out, and the proposed change written in. You pick who decides and how from the project's o"
     }
+  ],
+  "1.21.20": [
+    {
+      "id": "1004527",
+      "text": "Inside every Governor City building, the floors now show real numbers instead of \"not recorded yet\". The Charter reads each section from the rules in force. People shows who sits on the council, the testers, the ranks and newc"
+    }
   ]
 }

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

@@ -82,7 +82,7 @@ const item = (over = {}) => ({
   expired: false, closed_at: null, outcome: null, constitution: CONSENT, votes: [],
   ...over,
 });
-const none = () => ({ sources: new Map(), readings: new Map() });
+const none = () => ({ sources: new Map(), readings: new Map(), floors: new Map(), histories: new Map() });
 
 // ── 1. the mapper ────────────────────────────────────────────────────────────
 
@@ -285,7 +285,7 @@ test('the response shape: counts, line, street-ordered buildings, sorted matters
   c.readings.set('flow', { reading: 'flow', gate: { anyBuilder: true }, read: async () => ({ value: 3, figure: '3 stuck', line: 'longest wait 4 days, waiting for review', hot: true }) });
   const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'security.report.adjudicate'], contributions: c, now: NOW });
 
-  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'generated_at', 'line', 'matters', 'readings', 'sources', 'viewer', 'vocabulary'].sort());
+  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'floors', 'generated_at', 'history', 'history_sources', 'line', 'matters', 'readings', 'sources', 'viewer', 'vocabulary'].sort());
   assert.deepEqual(d.viewer, { id: '7' });
   // board 11 (needs) + board 12 (settled, closed this week) + blocker + report; board 13 is too old
   assert.deepEqual(d.counts, { needs: 2, moving: 1, settled: 1 });
@@ -512,6 +512,190 @@ test('each contributed source gates on EXACTLY the atom its own list route requi
   seams._reset();
 });
 
+// ── 5b. floors and the record (task 1004527) ────────────────────────────────
+
+const floorsDocket = require(path.join(ROOT, 'modules', 'government', 'docket-floors.js'));
+const economyDocket = require(path.join(ROOT, 'modules', 'economy', 'governor-docket.js'));
+
+const GOV = {
+  board: { membership: 'rank:metic+', pass_rule: 'majority' },
+  members: [{ builder_id: '7', github_login: 'ana', display_name: 'Ana' }, { builder_id: '9', github_login: 'theo', display_name: null }],
+  decisions: [
+    { area: 'people', name: 'People', who: 'whoever may manage ranks', rule: 'decide', rule_words: 'decides alone', as_today: true, decided_by: 'gate', gate: 'government.manage' },
+    { area: 'rules', name: 'Rules', who: 'whoever may change the project settings', rule: 'decide', rule_words: 'decides alone', as_today: true, decided_by: 'gate' },
+    { area: 'review', name: 'Review', who: 'testers', rule: 'signoff', rule_words: 'signed off by someone who did not build it', as_today: false, decided_by: 'rank:tester', set_by_item_id: '40' },
+    { area: 'release', name: 'Release', who: 'no one yet', rule: 'vacant', rule_words: 'no one holds this yet', as_today: false, decided_by: 'nobody' },
+    { area: 'treasury', name: 'Treasury', who: 'whoever may set spending limits', rule: 'decide', rule_words: 'decides alone', as_today: true, decided_by: 'gate' },
+  ],
+  holders: { review: [{ builder_id: '3', github_login: 'lu', display_name: 'Lu' }], release: [], charter: null },
+  genesis: { stages: [{ key: 'charter', label: 'the charter', state: 'passed', item_id: '1', closed_at: '2026-07-04T00:00:00Z' }, { key: 'pay', label: 'who can be paid', state: 'sitting', item_id: '2' }] },
+  ranks: [{ rank_key: 'metic', label: 'Metic', holders: 4 }, { rank_key: 'archon', label: 'Archon', holders: 1 }],
+  amendments: [{ item_id: '40', kind: 'decision_rules', rationale_md: '# Testers hold Review', closed_at: '2026-10-01T09:00:00Z', outcome: 'passed' }, { item_id: '41', kind: 'constitution', rationale_md: '', closed_at: '2026-09-02T09:00:00Z', outcome: 'returned' }],
+  closed: [{ id: '50', subject_type: 'full_idea', subject_id: '8', subject: { title: 'A template marketplace' }, closed_at: '2026-09-20T00:00:00Z', outcome: 'passed' }, { id: '40', subject_type: 'constitutional_amendment', closed_at: '2026-10-01T09:00:00Z', outcome: 'passed' }],
+  assignments: [{ builder_id: '3', github_login: 'lu', display_name: 'Lu', rank_key: 'tester', rank_label: 'Tester', is_system: false, assigned_at: '2026-09-30T00:00:00Z' }],
+};
+
+test('floors: every floor the design names is reported, and nothing is invented for one nobody answers', async () => {
+  const c = none();
+  let ran = false;
+  c.floors.set('release.live_month', { floor: 'release.live_month', gate: { anyBuilder: true }, read: async () => ({ count: 3, line: '3 pieces of work went live', lines: [['Invite flow', 'sep 26'], 'not a line', [''], ['x'.repeat(400), 'm']], hot: 'yes' }) });
+  c.floors.set('automation.running', { floor: 'automation.running', gate: { permission: 'autonomy.fence.manage' }, read: async () => { ran = true; return { count: '2' }; } });
+  c.floors.set('treasury.hosting', { floor: 'treasury.hosting', gate: { anyBuilder: true }, read: async () => { throw new Error('db down'); } });
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW });
+  assert.deepEqual(d.floors.map((f) => f.key), vocab.FLOORS.map((f) => f.key), 'every declared floor, in order');
+  const by = Object.fromEntries(d.floors.map((f) => [f.key, f]));
+  assert.deepEqual([by['release.live_month'].status, by['release.live_month'].count, by['release.live_month'].hot], ['live', '3', false]);
+  assert.deepEqual(by['release.live_month'].lines.map((l) => l[0].length), [11, 200], 'only real [text, meta] lines, bounded');
+  assert.deepEqual([by['automation.running'].status, by['automation.running'].count, ran], ['not_yours', '', false], 'a gated floor never runs');
+  assert.deepEqual([by['treasury.hosting'].status, by['treasury.hosting'].count], ['unavailable', '']);
+  assert.deepEqual([by['charter.purpose'].status, by['charter.purpose'].count], ['coming', '']);
+  assert.match(by['charter.purpose'].reason, /no written purpose/);
+  assert.deepEqual([by['treasury.grading'].status, by['treasury.grading'].count], ['off', ''], 'no contributor: off, no figure');
+  assert.equal(by['charter.council'].status, 'unavailable', 'no government read: unavailable, never an empty council');
+  assert.equal(by['planning.ideas'].status, 'live', 'ideas follow the board, which is live here');
+});
+
+test('floors: the government\'s own — council, sections, founding, ranks, testers — from the rows it read', async () => {
+  boardView = { open: [item({ id: '60', subject_type: 'full_idea', subject_id: '9', subject: { title: 'Weekly digest', author_id: '3' }, constitution: { membership: 'rank:metic+', pass_rule: 'majority' } })], closed: [] };
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: none(), now: NOW, decisions: GOV.decisions, government: GOV });
+  const by = Object.fromEntries(d.floors.map((f) => [f.key, f]));
+  assert.deepEqual([by['charter.council'].count, by['charter.council'].line], ['2', '2 seats · passes on more than half saying yes']);
+  assert.deepEqual(by['charter.council'].lines[0], ['Ana and theo.', 'seated now']);
+  assert.deepEqual(by['people.council'].lines[2], ['Seats have no term yet. Elections and recalls are coming.', 'coming']);
+  assert.deepEqual([by['charter.founding'].line, by['charter.founding'].hot], ['1 of 2 founding steps passed', true]);
+  assert.deepEqual(by['charter.review'].lines, [['Held by testers: signed off by someone who did not build it.', 'amended']]);
+  assert.deepEqual([by['charter.release'].line, by['charter.release'].lines[0][1]], ['held by no one yet', 'amended']);
+  assert.equal(by['charter.money'].line, 'whoever may set spending limits · decides alone');
+  assert.match(by['charter.membership'].line, /metic and above/);
+  assert.deepEqual([by['people.ranks'].count, by['people.ranks'].lines[0]], ['2', ['Metic', '4 people']]);
+  assert.match(by['people.ranks'].lines.at(-1)[0], /Promotion by a vote is coming/);
+  assert.deepEqual([by['review.testers'].count, by['review.testers'].line], ['1', 'Lu']);
+  assert.deepEqual([by['planning.ideas'].count, by['planning.ideas'].lines[0][0]], ['1', 'Weekly digest']);
+  // who holds each building: the people its row seats now
+  const b = Object.fromEntries(d.buildings.map((x) => [x.key, x]));
+  assert.deepEqual([b.review.holders, b.review.holder_count], [[{ id: '3', login: 'lu', name: 'Lu' }], 1]);
+  assert.deepEqual([b.release.holders, b.release.holder_count], [[], 0], 'vacant: no one, said as no one');
+  assert.deepEqual([b.charter.holders, b.planning.holders], [null, null], 'unresolved is null, never an invented seat');
+  // without the docket's own atom none of it shows
+  const out = await docket.buildDocket({ viewer: VIEWER, permissions: [], contributions: none(), now: NOW, decisions: GOV.decisions, government: GOV });
+  assert.ok(out.floors.filter((f) => floorsDocket.BUILDERS[f.key]).every((f) => f.status === 'not_yours' && f.count === ''));
+  assert.ok(out.buildings.every((x) => x.holders === null), 'holders are not shown without it');
+  assert.deepEqual(out.history, []);
+});
+
+test('the record: what closed, from every keeper, newest first; gated keepers never run; undated rows dropped', async () => {
+  boardView = { open: [], closed: [] };
+  const c = none();
+  let ran = false;
+  c.histories.set('releases', { history: 'releases', building: 'release', gate: { anyBuilder: true }, read: async () => [{ id: 9, title: 'Invite flow', at: '2026-09-26T00:00:00Z', outcome: 'live' }, { id: 10, title: 'No date', at: null }] });
+  c.histories.set('rulings', { history: 'rulings', building: 'disputes', gate: { permission: 'security.report.adjudicate' }, read: async () => { ran = true; return []; } });
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW, decisions: GOV.decisions, government: GOV });
+  assert.equal(ran, false);
+  assert.deepEqual(d.history.map((h) => [h.id, h.building, h.outcome]), [
+    ['government:amendment:40', 'charter', 'passed'],
+    ['government:rank:3:tester', 'people', 'granted'],
+    ['releases:9', 'release', 'live'],
+    ['government:board:50', 'planning', 'ratified'],
+    ['government:amendment:41', 'charter', 'returned'],
+    ['government:founding:1', 'charter', 'passed'],
+  ]);
+  assert.equal(d.history[4].title, 'A change to the charter', 'an amendment with no rationale reads as one');
+  assert.deepEqual(d.history_sources.map((s) => [s.source, s.status]), [['government', 'live'], ['releases', 'live'], ['rulings', 'not_yours']]);
+});
+
+test('lifecycle floors: goals kept of total, priorities, versions, signed off, live this month, held back, newcomers', () => {
+  const goals = [{ id: 1, title: 'Hall', status: 'open', version_id: 'V2' }, { id: 2, title: 'Payments', status: 'open', version_id: 'V2' }, { id: 3, title: 'Old', status: 'achieved', version_id: 'V1', updated_at: '2026-09-01T00:00:00Z' }];
+  const crit = [{ id: 'c1', goal_id: 1, satisfied: true, criterion_md: 'Search works', checked_at: '2026-10-01T00:00:00Z' }, { id: 'c2', goal_id: 1, satisfied: false }, { id: 'c3', goal_id: 9, satisfied: true, criterion_md: 'Old one', checked_at: '2026-09-03T00:00:00Z' }];
+  assert.deepEqual(lifecycleDocket.goalsFloor(goals, crit).lines, [['Hall', '1 of 2 kept'], ['Payments', 'no promises yet']]);
+  assert.equal(lifecycleDocket.goalsFloor(goals, crit).count, '2');
+  assert.deepEqual(lifecycleDocket.prioritiesFloor(goals, 'V2').lines[0], ['1 Hall · 2 Payments', 'version V2']);
+  assert.equal(lifecycleDocket.versionsFloor([{ id: 'V2', name: 'V2', status: 'building' }, { id: 'V1', name: 'V1', status: 'shipped', shipped_at: '2026-09-28T00:00:00Z' }], goals).line, 'V2 building · 2 goals in it');
+  const so = lifecycleDocket.signedOffFloor(crit, NOW);
+  assert.deepEqual([so.count, so.line, so.lines[0]], ['1', '1 signed off this month', ['Search works', 'oct 1']]);
+  const shipped = [{ id: 1, title: 'A', shipped_at: '2026-10-01T03:00:00Z' }, { id: 2, title: 'B', shipped_at: '2026-09-30T23:00:00Z' }];
+  assert.deepEqual([lifecycleDocket.liveMonthFloor(shipped, NOW).count, lifecycleDocket.liveMonthFloor(shipped, NOW).lines], ['1', [['A', 'oct 1']]], 'only this month');
+  assert.deepEqual(lifecycleDocket.heldBackFloor([{ title: 'X', needs_rebase: true }, { title: 'Y', needs_rebase: false }]).count, '1');
+  assert.equal(lifecycleDocket.newcomersFloor([{ title: 'N', newcomer_friendly: true }, { title: 'M' }], [{ newcomer_friendly: true }, { newcomer_friendly: true }]).lines.at(-1)[0], '2 newcomer tasks are ready to claim.');
+  assert.deepEqual(lifecycleDocket.signoffHistory(crit).map((h) => h.id), ['c1', 'c3']);
+  assert.deepEqual(lifecycleDocket.goalHistory(goals).map((h) => h.title), ['Old achieved']);
+  assert.deepEqual(lifecycleDocket.releaseHistory(shipped).map((h) => h.at), ['2026-10-01T03:00:00Z', '2026-09-30T23:00:00Z']);
+});
+
+test('automation, treasury and disputes floors read their own ledgers, and say so when there is nothing', () => {
+  const ag = autonomyDocket.allowedGoalsFloor({ priority_goal_id: 7, goals: [{ goal_id: 7, added_at: '2026-09-20T00:00:00Z' }, { goal_id: 8, added_at: '2026-09-02T00:00:00Z' }] });
+  assert.deepEqual([ag.count, ag.lines], ['2', [['goal 7', 'first in line'], ['goal 8', 'since sep 2']]]);
+  assert.equal(autonomyDocket.allowedGoalsFloor({ goals: [] }).line, 'no goal allowed');
+  const describe = (r) => ({ ok: r.alive, state: r.alive ? 'alive' : 'dead' });
+  const run = autonomyDocket.runningFloor([{ display_name: 'Ana', runners: [{ alive: true, working_task_id: '12' }, { alive: false, working_task_id: '13' }, { alive: true, working_task_id: null }] }], NOW, describe);
+  assert.deepEqual([run.count, run.lines], ['1', [['task 12', 'Ana']]], 'only a live runner on a task is building');
+  assert.deepEqual([autonomyDocket.spendingLimitFloor({ ceilingUsd: 40, spentUsd: 12 }).line, autonomyDocket.spendingLimitFloor({ ceilingUsd: 40, spentUsd: 35 }).hot], ['$40 a month · $12 used', true]);
+  const rep = autonomyDocket.reportsFloor([{ routine: 'builder', decision: 'go', created_at: '2026-09-30T00:00:00Z' }, { routine: 'idea-triage', decision: 'no-go', reason: 'nothing open', created_at: '2026-09-01T00:00:00Z' }], NOW);
+  assert.deepEqual([rep.count, rep.lines.map((l) => l[0])], ['1', ['The builder went ahead.', 'Idea sorting held back: nothing open.']], 'said in words, not the gate\'s keys');
+  const months = [{ month: '2026-10', rewards_credits: 1180, rewarded_builders: 6, grading_usd: 310.4, hosting_usd: 120 }, { month: '2026-09', rewards_credits: 4920, rewarded_builders: 8, grading_usd: 0, hosting_usd: 160 }];
+  assert.deepEqual([economyDocket.rewardsFloor(months, NOW).count, economyDocket.rewardsFloor(months, NOW).line], ['$1,180', '$1,180 this month · 6 builders']);
+  assert.deepEqual(economyDocket.hostingFloor(months, NOW).lines[1], ['$160 in sep.', 'last month']);
+  assert.equal(economyDocket.gradingFloor([], NOW).count, '$0', 'a month with no rows is a real zero, read from the ledger');
+  assert.deepEqual(economyDocket.treasuryHistory(months).map((h) => h.title), ['Paid $1,180 to 6 builders', 'AI grading cost $310', 'Hosting cost $120', 'Paid $4,920 to 8 builders', 'Hosting cost $160']);
+  assert.deepEqual(reportsRoute.rulingHistory([{ id: 1, title: 'sign-in limits', status: 'fixed', fixed_at: '2026-08-02T00:00:00Z' }, { id: 2, title: 'open one', status: 'open' }, { id: 3, title: 'undated', status: 'wontfix' }]).map((h) => [h.title, h.outcome]), [['Security report: sign-in limits', 'fixed']]);
+});
+
+test('rules in force: the landing rule and what it settled; the record by month', () => {
+  assert.deepEqual(ideasDocket.rulesFloor(18), { count: '1', line: '1 rule · settled 18 this month', lines: [['Every filing lands in its goal without a vote.', 'settled 18'], ['A new rule put to the council is coming.', 'coming']], hot: false });
+  assert.deepEqual(ideasDocket.rulesHistory([{ month: '2026-10', n: 3 }, { month: '2026-09', n: 0 }]).map((h) => [h.title, h.at]), [['The landing rule settled 3 filings', '2026-10-01T00:00:00.000Z']]);
+});
+
+test('one ledger read per docket request: the treasury floors and record share it, and so do money and the spending limit', async () => {
+  const costMod = require(path.join(ROOT, 'modules', 'economy', 'cost.js'));
+  const autoDb = require(path.join(ROOT, 'modules', 'autonomy', 'db.js'));
+  const realFence = autoDb.readFence;
+  let fences = 0;
+  autoDb.readFence = async () => { fences += 1; return { enabled: true, goals: [], updated_at: '2026-09-02T00:00:00Z' }; };
+  const realMonths = costMod.treasuryMonths;
+  let reads = 0;
+  costMod.treasuryMonths = async () => { reads += 1; return [{ month: '2026-10', rewards_credits: 10, rewarded_builders: 1, grading_usd: 2, hosting_usd: 3 }]; };
+  let spends = 0;
+  seams._reset();
+  seams.registerProvider('reward', { autonomousApiSpendMtd: async () => { spends += 1; return 5; } });
+  try {
+    for (const f of ['modules/economy/routes/cost.js', 'modules/autonomy/routes/autonomy.js']) require(path.join(ROOT, f))();
+    const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'autonomy.precheck'], now: NOW + 1 });
+    const by = Object.fromEntries(d.floors.map((f) => [f.key, f]));
+    assert.deepEqual([by['treasury.rewards'].count, by['treasury.hosting'].count, by['automation.spending_limit'].status], ['$10', '$3', 'live']);
+    assert.equal(reads, 1, 'one treasury read for three floors and the record');
+    assert.equal(spends, 1, 'one spend read for the money reading and the spending limit');
+    assert.equal(fences, 1, 'one fence read for the switch, allowed goals and the switch\'s record');
+    await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], now: NOW + 2 });
+    assert.equal(reads, 2, 'a new request reads afresh');
+    // two requests in flight at once, even at the same instant, each read once
+    reads = 0; spends = 0;
+    await Promise.all([1, 2, 3].map(() => docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'autonomy.precheck'], now: NOW + 3 })));
+    assert.deepEqual([reads, spends], [3, 3], 'one read per request, never shared across requests');
+  } finally {
+    costMod.treasuryMonths = realMonths;
+    autoDb.readFence = realFence;
+    seams._reset();
+  }
+});
+
+test('each floor and record gates on the atom of the route that serves its rows', async () => {
+  seams._reset();
+  for (const f of ['modules/ideas/routes/blockers.js', 'modules/lifecycle/routes/lifecycle.js', 'modules/security/routes/reports.js', 'modules/autonomy/routes/autonomy.js', 'modules/economy/routes/cost.js']) require(path.join(ROOT, f))();
+  const reg = docket.registeredContributions();
+  const routePerm = (file, key) => rrc.classifyText(fs.readFileSync(path.join(ROOT, file), 'utf8')).find((x) => x.key === key).perms;
+  assert.deepEqual([reg.floors.get('automation.running').gate.permission], routePerm('modules/autonomy/routes/autonomy.js', 'GET /autonomy/runners/all'));
+  for (const k of ['automation.spending_limit', 'automation.reports']) assert.deepEqual([reg.floors.get(k).gate.permission], routePerm('modules/autonomy/routes/autonomy.js', 'GET /autonomy/runs'));
+  assert.deepEqual([reg.histories.get('rulings').gate.permission], routePerm('modules/security/routes/reports.js', 'GET /security/reports'));
+  const anyBuilder = [...reg.floors].filter(([, c]) => c.gate.anyBuilder === true).map(([k]) => k).sort();
+  assert.deepEqual(anyBuilder, ['automation.allowed_goals', 'people.newcomers', 'planning.goals', 'planning.priorities', 'planning.versions', 'release.held_back', 'release.live_month', 'review.signed_off', 'rules.in_force', 'treasury.grading', 'treasury.hosting', 'treasury.rewards']);
+  // every declared floor has exactly one answer: a contributor, the government, or a coming reason
+  const own = new Set([...Object.keys(floorsDocket.BUILDERS), 'planning.ideas']);
+  for (const f of vocab.FLOORS) {
+    const answers = [reg.floors.has(f.key), own.has(f.key), docket.COMING_FLOORS.some((c) => c.floor === f.key)].filter(Boolean).length;
+    assert.equal(answers, 1, `${f.key} has one answer`);
+  }
+  seams._reset();
+});
+
 // ── 6. the route ─────────────────────────────────────────────────────────────
 
 const realRequireBuilder = api.requireBuilder;