@bongos/core 1.21.19 → 1.21.20

package/modules/government/docket.js

@@ -29,6 +29,17 @@
 //
 //   { reading: 'flow', gate: …, read: async (ctx) => { figure, line, value, hot } }
 //
+//   { floor: 'release.live_month', gate: …,          // one of docket-vocab FLOORS
+//     read: async (ctx) => { count, line, lines: [[text, meta]], hot } }
+//
+//   { history: 'releases', building: 'release', gate: …,   // the record drawers
+//     read: async (ctx) => [{ id, title, at, outcome }, …] }
+//
+// A FLOOR (task 1004527) is a state rather than a queue — who sits, what the
+// month cost, what went live — read by the module that owns it, under the same
+// atom as its own route. HISTORY is what closed: rulings, amendments, releases,
+// sign-offs, payouts; the building interior files it into drawers by month.
+//
 // `ctx` is { builderId, rank, has(permission) } — `has` answers from the
 // viewer's permission set resolved ONCE for this request, server-side and
 // uncached (ADR 0016). A contribution with no recognisable gate is DROPPED, never
@@ -61,9 +72,15 @@ const db = require('./db');
 const { resolveBoardMembers } = require('./board-membership');
 const resolver = require('./resolver');
 const decisionRules = require('./decision-rules');
+const docketFloors = require('./docket-floors');
+const governmentConfig = require('./config');
 
 const log = api.logger('government');
 
+// This module's own floors are answered under the docket route's own atom (the
+// same one GET /government/constitution and the genesis stages require).
+const GOVERNMENT_GATE = Object.freeze({ permission: 'board.vote.cast' });
+
 const CONTRIBUTION_POINT = 'governor.docket';
 
 // Every source the reference design names, with the building it stands in. The
@@ -94,6 +111,13 @@ const COMING_SOURCES = Object.freeze([
     reason: 'The project has no budget or spending votes recorded yet.' }),
 ]);
 
+// Floors the design names whose engine does not exist yet. Drawn, and say why.
+const COMING_FLOORS = Object.freeze([
+  Object.freeze({ floor: 'charter.purpose', reason: 'The charter has no written purpose yet. A section for it is coming.' }),
+]);
+const MAX_FLOOR_LINES = 6;
+const MAX_HISTORY_PER_SOURCE = 60;
+
 
 // A source read that has not answered by now is reported unavailable rather than
 // holding the whole city hostage (one source calls GitHub, one the npm registry).
@@ -151,6 +175,31 @@ function normalizeMatter(raw, { source, building }) {
   };
 }
 
+// One floor as a contributor handed it → { count, line, lines, hot }. Pure.
+// Anything that is not a plain object is not a floor (→ null, read as
+// unavailable); a count is kept only as the short figure it was given.
+function normalizeFloor(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const str = (v, n) => (v == null ? '' : String(v).slice(0, n));
+  const count = raw.count == null || raw.count === '' ? '' : str(raw.count, 12);
+  const lines = (Array.isArray(raw.lines) ? raw.lines : [])
+    .filter((l) => Array.isArray(l) && l[0] != null && String(l[0]).trim())
+    .slice(0, MAX_FLOOR_LINES)
+    .map((l) => [str(l[0], 200), str(l[1], 40)]);
+  return { count, line: str(raw.line, 90) || null, lines, hot: raw.hot === true };
+}
+
+// One closed thing for the record → the docket's one shape. Pure. A row with no
+// title or no readable date is dropped: an undated record is not a record.
+function normalizeHistory(raw, { source, building }) {
+  if (!raw || typeof raw !== 'object' || raw.id == null || !raw.title) return null;
+  const at = iso(raw.at);
+  if (!at) return null;
+  const b = vocab.BUILDING_KEYS.includes(raw.building) ? raw.building : building;
+  if (!vocab.BUILDING_KEYS.includes(b)) return null;
+  return { id: `${source}:${raw.id}`, source, building: b, title: String(raw.title).slice(0, 200), at, outcome: raw.outcome ? String(raw.outcome).slice(0, 40) : null };
+}
+
 // Does this viewer pass this gate? Fail-closed: anything unrecognised is false.
 function gateAllows(gate, ctx) {
   if (!gate || typeof gate !== 'object') return false;
@@ -346,12 +395,16 @@ function withTimeout(promise, ms) {
 function registeredContributions() {
   const sources = new Map();
   const readings = new Map();
+  const floors = new Map();
+  const histories = new Map();
   for (const c of api.contributions(CONTRIBUTION_POINT)) {
     if (!c || typeof c !== 'object' || typeof c.read !== 'function' || !hasValidGate(c.gate)) continue;
     if (typeof c.source === 'string' && c.source) sources.set(c.source, c);
     else if (typeof c.reading === 'string' && c.reading) readings.set(c.reading, c);
+    else if (typeof c.floor === 'string' && c.floor) floors.set(c.floor, c);
+    else if (typeof c.history === 'string' && c.history && vocab.BUILDING_KEYS.includes(c.building)) histories.set(c.history, c);
   }
-  return { sources, readings };
+  return { sources, readings, floors, histories };
 }
 
 // ── the collector ────────────────────────────────────────────────────────────
@@ -362,13 +415,22 @@ function registeredContributions() {
 // `decisions` is the resolved decision-rules table (board.decisionRulesView), or
 // null when it could not be read — each building's `decision` is then null
 // rather than a guess.
-async function buildDocket({ viewer, permissions, contributions = registeredContributions(), now = Date.now(), timeoutMs = SOURCE_TIMEOUT_MS, decisions = null } = {}) {
+// `government` is what docketFor() read once for this module's own floors and
+// record (loadGovernment below); null leaves those floors `unavailable`.
+async function buildDocket({ viewer, permissions, contributions = registeredContributions(), now = Date.now(), timeoutMs = SOURCE_TIMEOUT_MS, decisions = null, government = null } = {}) {
   const held = new Set(permissions || []);
   const ctx = Object.freeze({
     builderId: String(viewer.id),
     rank: viewer.rank || null,
     has: (p) => held.has(p),
   });
+  // A per-request memo every read may use, so two floors that need the same rows
+  // share one query (task 1004527). Scoped to this call: nothing outlives it.
+  const memo = new Map();
+  const once = (key, fn) => {
+    if (!memo.has(key)) memo.set(key, Promise.resolve().then(fn));
+    return memo.get(key);
+  };
   const sources = new Map(contributions.sources);
   sources.set('board', BOARD_SOURCE); // the board is read here, never contributed
   const comingKeys = new Set(COMING_SOURCES.map((c) => c.source));
@@ -392,7 +454,7 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
     }
     if (!gateAllows(c.gate, ctx)) { row.status = 'not_yours'; return; }
     try {
-      const raw = await withTimeout(Promise.resolve(c.read(ctx, { now })), timeoutMs);
+      const raw = await withTimeout(Promise.resolve(c.read(ctx, { now, once })), timeoutMs);
       const list = (Array.isArray(raw) ? raw : []).map((m) => normalizeMatter(m, { source: decl.source, building: c.building || decl.building })).filter(Boolean);
       row.status = 'live';
       row.count = list.length;
@@ -421,7 +483,7 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
     if (!impl) return { ...base, status: 'off', reason: 'The module that holds this is not enabled here.' };
     if (!gateAllows(impl.gate, ctx)) return { ...base, status: 'not_yours' };
     try {
-      const r = await withTimeout(Promise.resolve(impl.read(ctx, { now, matters })), timeoutMs);
+      const r = await withTimeout(Promise.resolve(impl.read(ctx, { now, matters, once })), timeoutMs);
       if (!r) return { ...base, status: 'unavailable', reason: 'It could not be read just now.' };
       return {
         ...base,
@@ -437,17 +499,83 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
     }
   }));
 
+  // Floors (task 1004527): contributed, this module's own (answered from
+  // `government`, under the docket's own atom), and Ideas to ratify (from the
+  // board's matters, so it can never disagree with the pins).
+  const govAllowed = gateAllows(GOVERNMENT_GATE, ctx);
+  const comingFloors = new Map(COMING_FLOORS.map((c) => [c.floor, c.reason]));
+  const floorImpls = new Map(contributions.floors || []);
+  const boardRow = sourceStatus.find((s) => s.source === 'board');
+  const floorsP = Promise.all(vocab.FLOORS.map(async (decl) => {
+    const base = { key: decl.key, building: decl.building, status: null, count: '', line: null, lines: [], hot: false, reason: null };
+    const live = (f) => (f ? { ...base, status: 'live', ...f } : { ...base, status: 'unavailable', reason: 'It could not be read just now.' });
+    if (decl.key === 'planning.ideas') {
+      if (!boardRow || boardRow.status !== 'live') return { ...base, status: boardRow ? boardRow.status : 'unavailable', reason: boardRow ? boardRow.reason : null };
+      return live(normalizeFloor(docketFloors.ideasFloor(matters)));
+    }
+    const own = docketFloors.BUILDERS[decl.key];
+    if (own) {
+      if (!govAllowed) return { ...base, status: 'not_yours' };
+      let f = null;
+      try { f = government ? normalizeFloor(own(government)) : null; } catch (err) { log.warn({ floor: decl.key, err: err && err.message }, 'governor docket floor failed'); }
+      return live(f);
+    }
+    const impl = floorImpls.get(decl.key);
+    if (!impl) {
+      return comingFloors.has(decl.key)
+        ? { ...base, status: 'coming', reason: comingFloors.get(decl.key) }
+        : { ...base, status: 'off', reason: 'The module that holds this is not enabled here.' };
+    }
+    if (!gateAllows(impl.gate, ctx)) return { ...base, status: 'not_yours' };
+    try {
+      return live(normalizeFloor(await withTimeout(Promise.resolve(impl.read(ctx, { now, once })), timeoutMs)));
+    } catch (err) {
+      log.warn({ floor: decl.key, err: err && err.message }, 'governor docket floor failed');
+      return { ...base, status: 'unavailable', reason: err && err.message === 'timeout' ? 'It did not answer in time.' : 'It could not be read just now.' };
+    }
+  }));
+
+  // The record: what closed, from every module that keeps it, newest first.
+  const history = [];
+  const historySources = [];
+  if (govAllowed && government) {
+    history.push(...docketFloors.governmentHistory(government).map((h) => normalizeHistory(h, { source: 'government', building: h.building })).filter(Boolean));
+    historySources.push({ source: 'government', status: 'live' });
+  }
+  const historyP = Promise.all([...(contributions.histories || new Map())].map(async ([key, c]) => {
+    if (!gateAllows(c.gate, ctx)) { historySources.push({ source: key, building: c.building, status: 'not_yours' }); return; }
+    try {
+      const raw = await withTimeout(Promise.resolve(c.read(ctx, { now, once })), timeoutMs);
+      const list = (Array.isArray(raw) ? raw : []).slice(0, MAX_HISTORY_PER_SOURCE).map((h) => normalizeHistory(h, { source: key, building: c.building })).filter(Boolean);
+      history.push(...list);
+      historySources.push({ source: key, building: c.building, status: 'live' });
+    } catch (err) {
+      log.warn({ history: key, err: err && err.message }, 'governor docket history failed');
+      historySources.push({ source: key, building: c.building, status: 'unavailable' });
+    }
+  }));
+  const [floors] = await Promise.all([floorsP, historyP]);
+  history.sort((a, b) => (a.at < b.at ? 1 : a.at > b.at ? -1 : a.id < b.id ? -1 : 1));
+  historySources.sort((a, b) => (a.source < b.source ? -1 : 1));
+
   const counts = countStates(matters);
   const decisionBy = new Map((Array.isArray(decisions) ? decisions : []).filter(Boolean).map((d) => [d.area, d]));
+  const holdersBy = govAllowed && government && government.holders ? government.holders : {};
   const buildings = vocab.BUILDINGS.map((b) => {
     const here = matters.filter((m) => m.building === b.key);
     const d = decisionBy.get(b.key) || null;
+    const held = Array.isArray(holdersBy[b.key]) ? holdersBy[b.key] : null;
     return {
       key: b.key, name: b.name, group: b.group, counts: countStates(here), matter_ids: here.map((m) => m.id),
       decision: d ? {
         who: d.who, rule: d.rule, rule_words: d.rule_words, decided_by: d.decided_by,
         as_today: d.as_today, sitting: d.sitting, set_by_item_id: d.set_by_item_id,
       } : null,
+      // Who holds the seat now, as the row seats them (task 1004527): the board's
+      // members, a sitting's predicate, or the holders of the fixed gate's atom.
+      // null when it could not be resolved — never an invented seat.
+      holders: held ? held.slice(0, 12).map((h) => person({ id: h.builder_id ?? h.id, login: h.github_login ?? h.login, name: h.display_name ?? h.name })).filter(Boolean) : null,
+      holder_count: held ? held.length : null,
     };
   });
   return {
@@ -459,6 +587,9 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
     buildings,
     sources: sourceStatus,
     readings,
+    floors,
+    history,
+    history_sources: historySources,
     vocabulary: {
       buildings: vocab.BUILDINGS, rules: vocab.RULES, states: vocab.STATES,
       // The table's rule set — the matter glyphs plus vacant (no one holds it).
@@ -477,14 +608,64 @@ async function docketFor(builder) {
     log.warn({ err: err && err.message }, 'governor docket: decision rules unreadable');
     return null;
   });
-  return buildDocket({ viewer: builder, permissions, decisions });
+  const government = permissions.includes(GOVERNMENT_GATE.permission) ? await loadGovernment({ decisions }) : null;
+  return buildDocket({ viewer: builder, permissions, decisions, government });
+}
+
+// This module's own floors and record, read ONCE per request (task 1004527),
+// each piece isolated: a read that fails leaves its piece null, which the pure
+// builders in docket-floors.js turn into an `unavailable` floor.
+//   holders  per building, the people its decision-rules row seats now: the
+//            board's members (charter), a sitting's predicate, or the active
+//            holders of a rank that grants the fixed gate's atom; [] when vacant.
+async function loadGovernment({ decisions }) {
+  const safe = (p, what) => Promise.resolve().then(p).catch((err) => {
+    log.warn({ err: err && err.message, what }, 'governor docket: a government read failed');
+    return null;
+  });
+  const { board: live } = governmentConfig.loadGovernmentConfig();
+  const [members, genesis, rankRows, assignments, amendments, room] = await Promise.all([
+    safe(() => resolveBoardMembers(live), 'members'),
+    safe(() => board.genesisStageStatus(), 'genesis'),
+    safe(() => db.listRanksWithGrants(), 'ranks'),
+    safe(() => db.listAssignments(), 'assignments'),
+    safe(() => db.listAmendmentHistory(50), 'amendments'),
+    safe(() => board.boardRoomView({ closedLimit: 50 }), 'closed'),
+  ]);
+  const ranks = rankRows && assignments ? rankRows.map((r) => ({
+    rank_key: r.rank_key, label: r.label,
+    holders: assignments.filter((a) => a.rank_key === r.rank_key).length,
+  })) : null;
+  let holders = null;
+  if (Array.isArray(decisions)) {
+    holders = {};
+    await Promise.all(decisions.filter(Boolean).map(async (d) => {
+      if (d.decided_by === 'board') { holders[d.area] = members; return; }
+      if (d.decided_by === 'nobody') { holders[d.area] = []; return; }
+      if (d.decided_by === 'gate') {
+        if (!rankRows || !d.gate) { holders[d.area] = null; return; }
+        const keys = rankRows.filter((r) => (r.permissions || []).includes(d.gate)).map((r) => r.rank_key);
+        holders[d.area] = keys.length ? await safe(() => db.getActiveBuildersWithRank(keys), `holders:${d.area}`) : [];
+        return;
+      }
+      holders[d.area] = await safe(() => resolveBoardMembers({ membership: d.decided_by }), `holders:${d.area}`);
+    }));
+  }
+  return {
+    board: live, decisions, members, genesis, ranks, assignments, amendments, holders,
+    closed: room && Array.isArray(room.closed) ? room.closed : null,
+  };
 }
 
 module.exports = {
   CONTRIBUTION_POINT,
   EXPECTED_SOURCES,
   COMING_SOURCES,
+  COMING_FLOORS,
   SOURCE_TIMEOUT_MS,
+  normalizeFloor,
+  normalizeHistory,
+  loadGovernment,
   SETTLED_WINDOW_MS,
   normalizeMatter,
   gateAllows,

package/modules/hall-ui/public/street-inside.js

@@ -24,20 +24,21 @@
 //    are about the government rather than the sample project). A floor the
 //    governor docket (GET /government/docket) already reads is BOUND to it: a
 //    source (its open matters, their count, needs you when one does) or a
-//    reading (its figure and line), or, for Planning's goals, the open goals the
-//    street already holds. Every other floor stands in an honest "not recorded
-//    yet" state: its name, what it holds, no number. Real data for every floor
-//    is task 1004527, which fills these same descriptors (floorFor()).
-//  * Who holds a building and how it decides. The docket does not carry a
-//    holder yet (task 1004529 sets who decides what, per project); until it
-//    does the seat is drawn empty and says so, and the rule is the one the
-//    building's own open matters are decided by, else the design's default,
-//    named as the default. A docket building that carries `holders` / `rule`
-//    is read first (holderOf()).
+//    reading (its figure and line), or a FLOOR (task 1004527: docket.floors, a
+//    state the owning module reads live — who sits, what the month cost, what
+//    went live). A floor whose engine does not exist yet comes back `coming`
+//    and stands faint with "not recorded yet" and the docket's reason; nothing
+//    here ever writes a number the docket did not send.
+//  * Who holds a building and how it decides: the building's `decision` row
+//    (task 1004529's table) and the `holders` that row seats now. Without a row
+//    the seat is drawn empty and says so, and the rule is the building's own
+//    matters' rule, else the design's default, named as the default
+//    (holderOf()).
 //  * On the table here: the docket's matters at this building. Each row opens
 //    the short card (GovStreet.cardFor(); task 1004528 makes it act).
-//  * The record: those same matters filed by the month they were opened, one
-//    drawer a month, newest first.
+//  * The record: the building's history (docket.history: rulings, amendments,
+//    sign-offs, releases, payouts) and its matters, filed by month, one drawer
+//    a month, newest first.
 //  * The annex lot stands when the building is full, as the prototype's
 //    "growth" lines say it would.
 //  * A district's work is the goal's tasks (GET /tasks?goal_id=N): shape from
@@ -268,7 +269,7 @@
       sym: f ? Object.assign(symbolPath(floorSymbol(f.name)), { c: '#fb9569' }) : { d: '', f: '', c: 'none' },
       flipA: ((st.picks || 0) % 2) === 0, flipB: ((st.picks || 0) % 2) === 1,
       openTitle: f ? f.name : '', openLines: f ? f.lines.map((l, i) => ({ key: 'l' + i, text: l[0], meta: l[1] })) : [],
-      drawers: record.map((r, i) => ({ key: r.label, index: i, label: r.label, count: r.items.length, aria: 'Open the ' + r.label + ' drawer', selected: i === selDrawer, bg: i === selDrawer ? T.wash : 'transparent', border: i === selDrawer ? T.ink : T.ruleStrong, handle: i === selDrawer ? T.ink : T.ruleStrong, color: T.ink })),
+      drawers: record.map((r, i) => ({ key: r.label, index: i, label: r.label, count: r.count == null ? r.items.length : r.count, aria: 'Open the ' + r.label + ' drawer', selected: i === selDrawer, bg: i === selDrawer ? T.wash : 'transparent', border: i === selDrawer ? T.ink : T.ruleStrong, handle: i === selDrawer ? T.ink : T.ruleStrong, color: T.ink })),
       drawerItems: selDrawer >= 0 ? record[selDrawer].items.map((it, i) => ({ key: 'r' + i, text: it[0], meta: it[1] })) : [],
       onFile: b.onFile, shapes: shapes, texts: texts, syms: syms, floors: floors,
       lift: { x: X - 38, y: GY - FH + 6, ty: -(selFloor * FH), h: FH - 16 },
@@ -314,7 +315,7 @@
   // its sample project: what it holds, the rule the design gives it, its
   // capacity, its growth line and its annex.
   const GROUPS = Object.freeze({ charter: 'how we decide', rules: 'how we decide', disputes: 'how we decide', people: 'who and what', planning: 'who and what', automation: 'the work', review: 'checks and going live', release: 'checks and going live', treasury: 'money' });
-  const RULE_WORDS = Object.freeze({ decide: 'one person decides', first: 'first yes wins', consent: 'passes unless someone objects', majority: 'more than half must say yes', unanimous: 'everyone has to agree', signoff: 'signed off by someone who did not build it', rule: 'settled by a rule' });
+  const RULE_WORDS = Object.freeze({ decide: 'one person decides', first: 'first yes wins', consent: 'passes unless someone objects', majority: 'more than half must say yes', unanimous: 'everyone has to agree', signoff: 'signed off by someone who did not build it', rule: 'settled by a rule', vacant: 'its matters wait until a seat is filled' });
 
   // A floor: [name, what it holds, binding]. A binding is { source }, { reading }
   // or { goals: true }; no binding is a floor not recorded yet.
@@ -322,12 +323,12 @@
     charter: {
       holds: 'The form of government. Seven sections say who holds each building and how it decides.', rule: 'unanimous', cap: 9,
       growth: 'Room for more sections before the charter needs a second volume.', annex: 'room for a second volume',
-      floors: [['Founding', 'the starting government'], ['§1 Purpose', 'what this project is for'], ['§2 Membership', 'who belongs, and how they join'], ['§3 The council', 'who sits on the council'], ['§4 Rules', 'how a rule passes'], ['§5 Money', 'who may spend, and how much'], ['§6 Review', 'who signs off finished work'], ['§7 Release', 'who puts work live']],
+      floors: [['Founding', 'the starting government', { floor: 'charter.founding' }], ['§1 Purpose', 'what this project is for', { floor: 'charter.purpose' }], ['§2 Membership', 'who belongs, and how they join', { floor: 'charter.membership' }], ['§3 The council', 'who sits on the council', { floor: 'charter.council' }], ['§4 Rules', 'how a rule passes', { floor: 'charter.rules' }], ['§5 Money', 'who may spend, and how much', { floor: 'charter.money' }], ['§6 Review', 'who signs off finished work', { floor: 'charter.review' }], ['§7 Release', 'who puts work live', { floor: 'charter.release' }]],
     },
     rules: {
       holds: 'Standing rules. Each one settles a kind of matter so the council never votes on it again.', rule: 'majority', cap: 8,
       growth: 'When the hall fills, the council can open an annex for one area, such as money rules.', annex: 'room for an annex, such as money rules',
-      floors: [['Rules in force', 'the rules settling matters now', { reading: 'rules' }], ['New rules', 'a rule put to the council', { source: 'standing_rules' }]],
+      floors: [['Rules in force', 'the rules settling matters now', { floor: 'rules.in_force', reading: 'rules' }], ['New rules', 'a rule put to the council', { source: 'standing_rules' }]],
     },
     disputes: {
       holds: 'Grade appeals, removal requests and security reports. Every ruling becomes precedent for the next one.', rule: 'decide', cap: 5,
@@ -337,32 +338,32 @@
     people: {
       holds: 'Who belongs, the rank each person holds, and who sits in which seat.', rule: 'consent', cap: 8,
       growth: 'A new floor opens whenever the charter creates a new seat.', annex: 'room for an annex of seats',
-      floors: [['The council', 'who sits, and for how long'], ['Testers', 'who signs off finished work'], ['Builders', 'who builds here', { reading: 'people' }], ['Newcomers', 'builders on newcomer tasks'], ['Waiting to join', 'asked to join the project', { source: 'access_requests' }], ['Ranks', 'the ranks, and who holds each'], ['Goal teams', 'asked to join a goal team', { source: 'goal_join_requests' }]],
+      floors: [['The council', 'who sits, and for how long', { floor: 'people.council' }], ['Testers', 'who signs off finished work', { floor: 'people.testers' }], ['Builders', 'who builds here', { reading: 'people' }], ['Newcomers', 'builders on newcomer tasks', { floor: 'people.newcomers' }], ['Waiting to join', 'asked to join the project', { source: 'access_requests' }], ['Ranks', 'the ranks, and who holds each', { floor: 'people.ranks' }], ['Goal teams', 'asked to join a goal team', { source: 'goal_join_requests' }]],
     },
     planning: {
       holds: 'Goals, and the promises that say when each one is done. Kept promises are what the project owes its users.', rule: 'majority', cap: 9,
       growth: 'When it fills, the next new goal opens a second planning office.', annex: 'room for a second planning office',
-      floors: [['Goals', 'the open goals', { goals: true }], ['Promises', 'what the goals say they deliver', { reading: 'promises' }], ['Ideas to ratify', 'full ideas waiting for a vote'], ['Priorities', 'the order goals are worked in'], ['Versions', 'what each version holds'], ['Waiting on a decision', 'blockers holding work', { source: 'blockers' }]],
+      floors: [['Goals', 'the open goals', { floor: 'planning.goals', goals: true }], ['Promises', 'what the goals say they deliver', { reading: 'promises' }], ['Ideas to ratify', 'full ideas waiting for a vote', { floor: 'planning.ideas' }], ['Priorities', 'the order goals are worked in', { floor: 'planning.priorities' }], ['Versions', 'what each version holds', { floor: 'planning.versions' }], ['Waiting on a decision', 'blockers holding work', { source: 'blockers' }]],
     },
     automation: {
       holds: 'AI builders working on their own. You choose which goals they may build and how much they may spend, and you can stop them at any time.', rule: 'decide', cap: 6,
       growth: 'A new floor opens for each goal you let it build.', annex: 'room for an annex',
-      floors: [['The switch', 'unattended building, on or off', { source: 'autobongos_fence' }], ['Allowed goals', 'the goals it may build'], ['Running now', 'builds in progress'], ['Spending limit', 'what it may spend a day'], ['Reports', 'what it did, told without asking']],
+      floors: [['The switch', 'unattended building, on or off', { source: 'autobongos_fence' }], ['Allowed goals', 'the goals it may build', { floor: 'automation.allowed_goals' }], ['Running now', 'builds in progress', { floor: 'automation.running' }], ['Spending limit', 'what it may spend', { floor: 'automation.spending_limit' }], ['Reports', 'what it did, told without asking', { floor: 'automation.reports' }]],
     },
     review: {
       holds: 'Testing finished work and signing it off. Work does not count until someone who did not build it says it works.', rule: 'signoff', cap: 5,
       growth: 'When one queue of testers is not enough, an annex can take design reviews.', vacantGrowth: 'Nothing is built here until the charter says who holds the seat.', annex: 'room for an annex, such as design review',
-      floors: [['Testers', 'who signs off finished work'], ['Waiting outside', 'finished work waiting for a tester', { source: 'criteria_uat' }], ['Signed off', 'work a tester has signed off']],
+      floors: [['Testers', 'who signs off finished work', { floor: 'review.testers' }], ['Waiting outside', 'finished work waiting for a tester', { source: 'criteria_uat', held: 'Being tested' }], ['Signed off', 'work a tester has signed off', { floor: 'review.signed_off' }]],
     },
     release: {
       holds: 'Putting finished work live, and taking updates to Bongos itself.', rule: 'decide', cap: 7,
       growth: 'Room for a second gate if releases are ever split by area.', annex: 'room for a second gate',
-      floors: [['Overrides', 'past a failed check or grade', { source: 'override_requests' }], ['Modules', 'listed modules, and their re-checks', { source: 'module_rechecks' }], ['Held back', 'work held from going live'], ['Core update', 'a new version of Bongos', { source: 'core_update' }], ['Live this month', 'what went live'], ['Ready to go', 'signed off, waiting to go live', { source: 'gate_approvals' }]],
+      floors: [['Overrides', 'past a failed check or grade', { source: 'override_requests' }], ['Modules', 'listed modules, and their re-checks', { source: 'module_rechecks' }], ['Held back', 'work held from going live', { floor: 'release.held_back' }], ['Core update', 'a new version of Bongos', { source: 'core_update' }], ['Live this month', 'what went live', { floor: 'release.live_month' }], ['Ready to go', 'signed off, waiting to go live', { source: 'gate_approvals' }]],
     },
     treasury: {
       holds: 'The budget, and who gets paid for what.', rule: 'majority', cap: 7,
       growth: 'Each new spending line takes a floor.', annex: 'room for an annex of spending lines',
-      floors: [['Builder rewards', 'paid for shipped work'], ['AI grading', 'the reviewer that grades every ship'], ['Hosting', 'servers and storage'], ['Reserve', 'what is left this month', { reading: 'money' }], ['Spending matters', 'spending put to a vote', { source: 'treasury_spending' }]],
+      floors: [['Builder rewards', 'paid for shipped work', { floor: 'treasury.rewards' }], ['AI grading', 'the reviewer that grades every ship', { floor: 'treasury.grading' }], ['Hosting', 'servers and storage', { floor: 'treasury.hosting' }], ['Reserve', 'what is left this month', { reading: 'money' }], ['Spending matters', 'spending put to a vote', { source: 'treasury_spending' }]],
     },
   });
   const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
@@ -396,6 +397,18 @@
     const docket = ctx.docket, now = ctx.now;
     if (!bind) return F(name, what, '', 'coming', [['What this floor holds is not recorded in Bongos yet.', 'coming']]);
     if (!docket) return F(name, what, '', 'unavailable', [['The docket could not be read just now.', '']]);
+    if (bind.floor) {
+      const fl = (Array.isArray(docket.floors) ? docket.floors : []).find((x) => x && x.key === bind.floor);
+      if (fl && fl.status === 'live') {
+        const titles = new Map((ctx.goals || []).map((g) => [String(g.id), String(g.title || '')]));
+        // a line that names a goal by id ('goal 12') is lettered with its title
+        const word = (t) => { const m = /^goal (\d+)$/.exec(String(t)); return m && titles.get(m[1]) ? titles.get(m[1]) : String(t); };
+        const lines = (Array.isArray(fl.lines) ? fl.lines : []).map((l) => [word(l[0]), String(l[1] || '')]);
+        return F(name, String(fl.line || what), fl.count == null ? '' : String(fl.count), fl.hot ? 'pending' : 'ok', lines.length ? lines : [[String(fl.line || what), '']]);
+      }
+      if (fl) return quietFloor(name, what, fl.status, fl.reason);
+      if (!bind.goals && !bind.reading) return F(name, what, '', 'unavailable', [['This could not be read just now.', '']]);
+    }
     if (bind.goals) {
       const goals = ctx.goals || [];
       const lines = goals.slice(0, MAX_LINES).map((g) => [String(g.title || 'Goal ' + g.id), 'open']);
@@ -423,36 +436,73 @@
     return F(name, what, '', 'unavailable', [[String(reason || 'It could not be read just now.'), '']]);
   }
 
-  // Who holds the building and how it decides. A docket building that names
-  // its holders (task 1004529) is read first; otherwise the seat is empty and
-  // says so, and the rule is its matters' own, else the design's default (and
-  // the words say 'by default', so a default is never read as a decision).
-  function holderOf(key, info, matters) {
+  // Who holds the building and how it decides. The building's decision row
+  // (task 1004529's table) is read first, with the people it seats now
+  // (`holders`); a vacant row is an empty seat that says so. A building with no
+  // row falls back to the legacy `holders` / `who` / `rule`, then its matters'
+  // own rule, then the design's default (and the words say 'by default', so a
+  // default is never read as a decision).
+  function holderOf(key, info, matters, viewerId) {
     const plan = PLAN[key];
     const holders = info && Array.isArray(info.holders) ? info.holders.filter((h) => h && (h.name || h.login)) : [];
-    const seats = holders.length ? holders.slice(0, 5).map((h) => String(h.name || h.login).charAt(0).toUpperCase()) : ['—'];
-    const who = info && info.who ? String(info.who) : holders.length ? holders.map((h) => String(h.name || h.login)).join(', ') : 'who holds it is not set on this project yet';
+    const nameOf = (h) => String(h.name || h.login);
+    const seatOf = (h) => (viewerId != null && h.id != null && String(h.id) === String(viewerId) ? 'you' : nameOf(h).charAt(0).toUpperCase());
+    const d = info && info.decision && typeof info.decision === 'object' ? info.decision : null;
+    if (d) {
+      if (d.rule === 'vacant') return { seats: ['—'], who: 'no one holds it yet', rule: 'vacant', how: RULE_WORDS.vacant };
+      const rule = RULE_WORDS[d.rule] ? d.rule : plan.rule;
+      const n = info.holder_count == null ? holders.length : Number(info.holder_count) || 0;
+      const named = holders.slice(0, 3).map(nameOf);
+      const people = !n || !named.length ? '' : n <= 3 ? (named.length > 1 ? named.slice(0, -1).join(', ') + ' and ' + named[named.length - 1] : named[0]) : named.join(', ') + ' and ' + (n - 3) + ' more';
+      return {
+        seats: holders.length ? holders.slice(0, 5).map(seatOf) : ['—'],
+        who: people ? people + ' · ' + String(d.who || '') : String(d.who || 'who holds it is not set on this project yet'),
+        rule: rule,
+        how: RULE_WORDS[rule] + (RULE_WORDS[d.rule] ? '' : ' · by default'),
+      };
+    }
+    const seats = holders.length ? holders.slice(0, 5).map(seatOf) : ['—'];
+    const who = info && info.who ? String(info.who) : holders.length ? holders.map(nameOf).join(', ') : 'who holds it is not set on this project yet';
     const fromMatter = matters.find((m) => m && RULE_WORDS[m.rule]);
     const rule = info && RULE_WORDS[info.rule] ? info.rule : fromMatter ? fromMatter.rule : plan.rule;
     const how = RULE_WORDS[rule] + (info && RULE_WORDS[info.rule] ? '' : fromMatter ? '' : ' · by default');
     return { seats: seats, who: who, rule: rule, how: how };
   }
 
-  // The record: the building's matters filed by the month each was opened.
-  function recordOf(matters, now) {
+  // The record: the building's history (what closed, dated by when it closed)
+  // and its matters (dated by when each was opened), filed by month, newest
+  // drawer first. A settled sitting that is also in the history is filed once.
+  // A drawer shows MAX_DRAWER items and says how many more; its count is all.
+  const MAX_DRAWER = 12;
+  function recordOf(matters, now, history) {
     const by = new Map();
-    matters.forEach((m) => {
-      const t = m.opened_at ? new Date(m.opened_at) : null;
+    const file = (at, item) => {
+      const t = at ? new Date(at) : null;
       const ok = t && !isNaN(t.getTime());
       const k = ok ? t.getUTCFullYear() * 12 + t.getUTCMonth() : -1;
       if (!by.has(k)) by.set(k, []);
-      by.get(k).push([String(m.title || m.short || ''), STATE_WORDS[stateOf(m)]]);
+      by.get(k).push(item);
+    };
+    const filed = new Set();
+    (history || []).forEach((h) => {
+      const m = /:(?:board|amendment|founding):(.+)$/.exec(String(h.id || ''));
+      if (m) filed.add(m[1]);
+    });
+    (history || []).forEach((h) => file(h.at, [String(h.title || ''), String(h.outcome || '')]));
+    matters.forEach((m) => {
+      if (m.ref && m.ref.type === 'board_item' && filed.has(String(m.ref.id))) return;
+      file(m.opened_at, [String(m.title || m.short || ''), STATE_WORDS[stateOf(m)]]);
     });
     const thisYear = new Date(now || 0).getUTCFullYear();
-    return [...by.keys()].sort((a, b) => b - a).map((k) => ({
-      label: k < 0 ? 'undated' : MONTHS[k % 12] + (Math.floor(k / 12) === thisYear ? '' : ' ' + String(Math.floor(k / 12)).slice(2)),
-      items: by.get(k),
-    }));
+    return [...by.keys()].sort((a, b) => b - a).map((k) => {
+      const all = by.get(k);
+      const items = all.slice(0, MAX_DRAWER);
+      if (all.length > MAX_DRAWER) items.push(['and ' + (all.length - MAX_DRAWER) + ' more', '']);
+      return {
+        label: k < 0 ? 'undated' : MONTHS[k % 12] + (Math.floor(k / 12) === thisYear ? '' : ' ' + String(Math.floor(k / 12)).slice(2)),
+        items: items, count: all.length,
+      };
+    });
   }
 
   // The whole building as civicInfo() shaped it, from the real feeds.
@@ -464,21 +514,27 @@
     const c = { key: key, docket: docket, goals: (ctx && ctx.goals) || [], now: (ctx && ctx.now) || 0 };
     const matters = docket ? docket.matters.filter((m) => m && m.building === key) : [];
     const info = docket && Array.isArray(docket.buildings) ? docket.buildings.find((b) => b && b.key === key) : null;
-    const h = holderOf(key, info, matters);
-    const vacant = key === 'review' && !S.reviewHeldOf(docket);
-    const floors = plan.floors.map((spec) => floorFor(spec, c));
+    const h = holderOf(key, info, matters, docket && docket.viewer ? docket.viewer.id : null);
+    const vacant = key === 'review' && (!S.reviewHeldOf(docket) || !!(info && info.decision && info.decision.rule === 'vacant'));
+    // a held Review's waiting floor is the prototype's 'Being tested'
+    const floors = plan.floors.map((spec) => {
+      const fl = floorFor(spec, c);
+      if (!vacant && spec[2] && spec[2].held) fl.name = spec[2].held;
+      return fl;
+    });
     const order = { needs: 0, moving: 1, settled: 2 };
     const table = matters.slice().sort((a, b) => order[stateOf(a)] - order[stateOf(b)]).map((m) => {
       const s = stateOf(m), when = S.whenWord(m.deadline, c.now);
       return { key: String(m.id), matter: String(m.id), label: String(m.title || m.short || ''), status: s === 'needs' ? 'needs you' + (when ? ' · ' + when : '') : s === 'moving' ? 'moving' + (when ? ' · ' + when : '') : (when || 'settled'), state: s, color: s === 'needs' ? 'accent' : 'ink' };
     });
-    const record = recordOf(matters, c.now);
+    const history = docket && Array.isArray(docket.history) ? docket.history.filter((x) => x && x.building === key) : [];
+    const record = recordOf(matters, c.now, history);
     return {
       key: key, group: GROUPS[key], name: info && info.name ? String(info.name) : key.charAt(0).toUpperCase() + key.slice(1), holds: plan.holds,
       seats: h.seats, who: h.who, rule: h.rule, how: h.how, cap: plan.cap,
       growth: vacant ? plan.vacantGrowth : plan.growth,
       floors: floors, record: record,
-      onFile: !docket ? 'the docket could not be read just now' : matters.length ? matters.length + (matters.length === 1 ? ' matter' : ' matters') + ' on the docket' : 'nothing on file yet',
+      onFile: !docket ? 'the docket could not be read just now' : matters.length ? matters.length + (matters.length === 1 ? ' matter' : ' matters') + ' on the docket' + (history.length ? ' · ' + history.length + ' on the record' : '') : history.length ? history.length + ' on the record' : 'nothing on file yet',
       table: table, annex: !vacant && floors.length >= plan.cap ? plan.annex : null, vacant: vacant,
     };
   }

package/modules/ideas/governor-docket.js

@@ -57,6 +57,37 @@ function rulesReading(settledThisMonth) {
   };
 }
 
+// Rules · Rules in force (task 1004527): each standing rule and how many
+// matters it settled this month. The project records one standing rule today,
+// the landing rule; a rule put to the council has nowhere to live yet (the
+// docket's standing_rules source says coming). Pure.
+const LANDING_RULE = 'Every filing lands in its goal without a vote.';
+function rulesFloor(settledThisMonth) {
+  const n = Number(settledThisMonth) || 0;
+  return {
+    count: '1',
+    line: `1 rule · settled ${n} this month`,
+    lines: [[LANDING_RULE, `settled ${n}`], ['A new rule put to the council is coming.', 'coming']],
+    hot: false,
+  };
+}
+// The Rules record: what the landing rule settled, month by month. Pure.
+function rulesHistory(months) {
+  return (months || []).filter((m) => Number(m.n) > 0).map((m) => ({
+    id: `landing:${m.month}`, title: `The landing rule settled ${m.n} ${Number(m.n) === 1 ? 'filing' : 'filings'}`,
+    at: `${m.month}-01T00:00:00.000Z`, outcome: 'without a vote',
+  }));
+}
+async function routedByMonth(months = 6) {
+  const { rows } = await api.pool.query(
+    `SELECT to_char(created_at, 'YYYY-MM') AS month, count(*)::int AS n FROM ideas_task_lineage
+      WHERE origin = 'route' AND created_at >= date_trunc('month', now()) - (($1::int - 1) * interval '1 month')
+      GROUP BY month ORDER BY month DESC`,
+    [months],
+  );
+  return rows;
+}
+
 // Filings the routing rule landed this month (origin 'route').
 async function countRoutedThisMonth() {
   const { rows } = await api.pool.query(
@@ -66,6 +97,12 @@ async function countRoutedThisMonth() {
   return rows[0] ? rows[0].n : 0;
 }
 
+// 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 routedFor = (once) => shared(once, 'ideas.routedThisMonth', () => countRoutedThisMonth());
+
 function contributeIdeasToDocket() {
   api.contribute(POINT, {
     source: 'blockers',
@@ -81,13 +118,17 @@ function contributeIdeasToDocket() {
   api.contribute(POINT, {
     reading: 'rules',
     gate: { anyBuilder: true },
-    read: async () => rulesReading(await countRoutedThisMonth()),
+    read: async (_ctx, { once } = {}) => rulesReading(await routedFor(once)),
   });
+  api.contribute(POINT, { floor: 'rules.in_force', gate: { anyBuilder: true }, read: async (_ctx, { once } = {}) => rulesFloor(await routedFor(once)) });
+  api.contribute(POINT, { history: 'rules', building: 'rules', gate: { anyBuilder: true }, read: async () => rulesHistory(await routedByMonth()) });
 }
 
 module.exports = {
   contributeIdeasToDocket,
   blockerDocketMatter,
   rulesReading,
+  rulesFloor,
+  rulesHistory,
   countRoutedThisMonth,
 };