@bongos/core 1.21.112 → 1.21.114

package/modules/government/treasury-db.js

@@ -0,0 +1,166 @@
+'use strict';
+
+// modules/government/treasury-db.js — the treasury's reads and writes (task
+// 1004712, government_031; ADR 0379). The rules live in treasury.js; this file
+// only reads real spend, the stored pots and loans, and writes the two things
+// the treasury decides: a goal's budget and a loan's answer.
+//
+// REAL SPEND, NOT A COPY OF IT. A pot's spend is summed from cost_log through
+// each task's goal on every read, in the calendar month cost-summary's by_month
+// uses (to_char(recorded_at, 'YYYY-MM')), so the treasury and the spend chart
+// can never disagree about a month. Nothing is cached (ADR 0016's posture).
+//
+// The pool comes through the published doorway (ADR 0091 §2).
+
+const { pool } = require('../../src/module-api');
+const api = require('../../src/module-api');
+const treasury = require('./treasury');
+const asksDb = require('./asks-db');
+
+// This month's and last month's real spend: the totals, and this month's per goal.
+async function readSpend(month) {
+  const last = treasury.prevMonth(month);
+  const [totals, byGoal] = await Promise.all([
+    pool.query(
+      `SELECT to_char(recorded_at, 'YYYY-MM') AS month, COALESCE(SUM(amount_usd), 0) AS total_usd
+         FROM cost_log
+        WHERE recorded_at >= now() - interval '75 days'
+          AND to_char(recorded_at, 'YYYY-MM') IN ($1, $2)
+        GROUP BY 1`,
+      [month, last],
+    ),
+    pool.query(
+      `SELECT t.goal_id, COALESCE(SUM(cl.amount_usd), 0) AS total_usd
+         FROM cost_log cl
+         JOIN tasks t ON t.id = cl.task_id
+        WHERE cl.recorded_at >= now() - interval '40 days'
+          AND to_char(cl.recorded_at, 'YYYY-MM') = $1
+          AND t.goal_id IS NOT NULL
+        GROUP BY t.goal_id`,
+      [month],
+    ),
+  ]);
+  const of = (m) => Number((totals.rows.find((r) => r.month === m) || {}).total_usd) || 0;
+  const by = {};
+  for (const r of byGoal.rows) by[String(r.goal_id)] = Number(r.total_usd) || 0;
+  return { month_usd: of(month), last_month_usd: of(last), by_goal: by };
+}
+
+async function listPots() {
+  const { rows } = await pool.query('SELECT goal_id, budget_usd, set_by, set_at FROM government_pots ORDER BY goal_id');
+  return rows;
+}
+
+async function listOpenGoals() {
+  const { rows } = await pool.query("SELECT id, title, status FROM goals WHERE status = 'open' ORDER BY id");
+  return rows;
+}
+
+// This month's borrows, and any still open from before.
+async function listBorrows(month) {
+  const { rows } = await pool.query(
+    `SELECT id, goal_id, month, amount_usd, budget_usd, spent_usd, filed_at, state, lent_usd, answer_key, answered_by, answered_at
+       FROM government_pot_borrows
+      WHERE month = $1 OR state = 'open'
+      ORDER BY id`,
+    [month],
+  );
+  return rows;
+}
+
+async function getBorrow(id) {
+  const { rows } = await pool.query(
+    `SELECT b.id, b.goal_id, b.month, b.amount_usd, b.budget_usd, b.spent_usd, b.filed_at, b.state, b.lent_usd,
+            b.answer_key, b.answered_by, b.answered_at, g.title
+       FROM government_pot_borrows b JOIN goals g ON g.id = b.goal_id
+      WHERE b.id = $1::bigint`,
+    [id],
+  );
+  return rows[0] || null;
+}
+
+// The spend cap, off unless the project set one (project_settings, read uncached).
+async function readCap() {
+  const r = await api.projectSettings.resolveSpendCap();
+  return { usd: r.usd, source: r.source };
+}
+
+// The whole treasury, read once, as treasury.buildTreasury shapes it.
+async function readTreasury({ now = Date.now() } = {}) {
+  const month = treasury.monthKey(now);
+  const [goals, pots, spend, borrows, cap] = await Promise.all([listOpenGoals(), listPots(), readSpend(month), listBorrows(month), readCap()]);
+  return treasury.buildTreasury({ now, goals, pots, spend, borrows, cap });
+}
+
+// Give a goal a pot, change its budget, or (budget null) take it away.
+async function setPot({ goalId, budget, builderId }) {
+  if (budget == null) {
+    const { rowCount } = await pool.query('DELETE FROM government_pots WHERE goal_id = $1::bigint', [goalId]);
+    return { removed: rowCount > 0 };
+  }
+  const { rows } = await pool.query(
+    `INSERT INTO government_pots (goal_id, budget_usd, set_by, set_at)
+     VALUES ($1::bigint, $2, $3, now())
+     ON CONFLICT (goal_id) DO UPDATE SET budget_usd = EXCLUDED.budget_usd, set_by = EXCLUDED.set_by, set_at = now()
+     RETURNING goal_id, budget_usd, set_by, set_at`,
+    [goalId, budget, builderId == null ? null : builderId],
+  );
+  return { pot: rows[0] };
+}
+
+async function goalById(goalId) {
+  const { rows } = await pool.query('SELECT id, title, status FROM goals WHERE id = $1::bigint', [goalId]);
+  return rows[0] || null;
+}
+
+// FILE THE BORROWS. Every dry pot with nothing open, and no "no" this month,
+// files one: the row (open), then its ask in the stored shape on the docket id
+// treasury_spending:<id>, waiting on lead:treasury. The one-open index makes a
+// racing second filer a no-op. → [{ goal_id, borrow_id, amount_usd }]
+async function fileBorrows({ now = Date.now(), view = null } = {}) {
+  const t = view || await readTreasury({ now });
+  const borrows = await listBorrows(t.month);
+  const filed = [];
+  for (const pot of t.pots) {
+    if (!treasury.needsBorrow(pot, borrows, t.month)) continue;
+    const amount = treasury.borrowAmount(pot, now);
+    const ask = treasury.borrowAsk({ title: pot.title, amount_usd: amount, spent_usd: pot.spent_usd, budget_usd: pot.budget_usd, lent_usd: pot.lent_usd, cap: t.cap, month_usd: t.spend.month_usd });
+    const { rows } = await pool.query(
+      `INSERT INTO government_pot_borrows (goal_id, month, amount_usd, budget_usd, spent_usd)
+       VALUES ($1::bigint, $2, $3, $4, $5)
+       ON CONFLICT (goal_id) WHERE state = 'open' DO NOTHING
+       RETURNING id`,
+      [pot.goal_id, t.month, amount, pot.budget_usd + pot.lent_usd, pot.spent_usd],
+    );
+    if (!rows[0]) continue;
+    await asksDb.saveAsk({ matterId: treasury.matterId(rows[0].id), ask, builderId: null });
+    filed.push({ goal_id: pot.goal_id, borrow_id: String(rows[0].id), amount_usd: amount });
+  }
+  return filed;
+}
+
+// Answer an open borrow. The trigger refuses a second answer, so a race is a 0-row no-op.
+async function answerBorrow({ id, answer, builderId }) {
+  const { rows } = await pool.query(
+    `UPDATE government_pot_borrows
+        SET state = $2, lent_usd = $3, answer_key = $4, answered_by = $5
+      WHERE id = $1::bigint AND state = 'open'
+      RETURNING id, goal_id, month, amount_usd, budget_usd, spent_usd, filed_at, state, lent_usd, answer_key, answered_by, answered_at`,
+    [id, answer.state, answer.lent_usd, answer.answer_key, builderId],
+  );
+  return rows[0] || null;
+}
+
+// The open borrows as docket matters, with their stored asks.
+async function openBorrowRows() {
+  const { rows } = await pool.query(
+    `SELECT b.id, b.goal_id, b.month, b.amount_usd, b.budget_usd, b.spent_usd, b.filed_at, b.state, g.title
+       FROM government_pot_borrows b JOIN goals g ON g.id = b.goal_id
+      WHERE b.state = 'open'
+      ORDER BY b.id`,
+  );
+  const stored = await asksDb.asksFor(rows.map((r) => treasury.matterId(r.id)));
+  return rows.map((r) => ({ row: r, ask: stored.get(treasury.matterId(r.id)) || null }));
+}
+
+module.exports = { readSpend, listPots, listOpenGoals, listBorrows, getBorrow, readCap, readTreasury, setPot, goalById, fileBorrows, answerBorrow, openBorrowRows };

package/modules/government/treasury.js

@@ -0,0 +1,241 @@
+'use strict';
+
+// modules/government/treasury.js — THE TREASURY: a pot per goal, the reserve,
+// and the borrow a dry pot asks for (task 1004712, goal 1000111 "government is
+// how a project steers its AI"; ADR 0379).
+//
+// The project's AI spend is its treasury. The owner's rulings (2026-10-09):
+//   * there is NO spend limit by default. A cap is an optional project setting
+//     (project_settings['treasury.spend_cap_usd']), off until someone sets it;
+//   * a goal MAY have a pot: a monthly budget the Treasury's holder gives it;
+//   * when a pot runs dry, it asks to BORROW FROM THE RESERVE, and that borrow
+//     is a treasury matter: an ask in the stored ask shape (asks.js), waiting on
+//     lead:treasury, routed by routing.js to the Treasury's Lead, or the owner
+//     while it is unseated.
+//
+// WHAT IS REAL, AND FROM WHERE. Every dollar of spend is cost_log's: a pot's
+// spend this month is the cost_log rows whose task is in the goal, this calendar
+// month (the month cost-summary's by_month uses). What is stored is only what the
+// treasury decided: a goal's budget (government_pots) and each loan
+// (government_pot_borrows). Nothing here moves money or touches a payment
+// provider; this is the project's own accounting over its real spend.
+//
+//   pot.spent_usd   this month's real spend on the goal's tasks
+//   pot.budget_usd  the budget its holder gave it (stored)
+//   pot.lent_usd    what the reserve lent it this month (stored loans)
+//   pot.dry         spent >= budget + lent
+//   reserve         last month's real spend that no pot was given this month,
+//                   less what it has lent this month. A month that spent more
+//                   than that is overdrawn (negative): with no limit, work runs
+//                   anyway and the overspend shows as debt.
+//
+// A borrow asks for what the pot will need to finish the month at its pace
+// (spend so far over the share of the month gone), rounded up to $50.
+//
+// PURE: no db, no clock of its own (now is passed in). treasury-db.js reads and
+// writes; the poller (pollers/treasury-borrow.js) files borrows; the route reads.
+
+const asks = require('./asks');
+
+const MATTER_SOURCE = 'treasury_spending';
+const SEAT = 'lead:treasury';
+const ROUND_USD = 50;
+const MAX_BUDGET_USD = 1000000;
+const ANSWERS = Object.freeze(['lend', 'half', 'no']);
+// An act on the docket matter: the deck maps an ask option's act 'answer:<key>'
+// onto it (street-deck.js actFor), and the card sends it to the answer route.
+const ACT_KEY = 'answer';
+
+const num = (v) => { const n = Number(v); return Number.isFinite(n) ? n : 0; };
+const round2 = (v) => Math.round(num(v) * 100) / 100;
+const str = (v) => (v == null ? '' : String(v));
+function usd(v) { return '$' + Math.round(num(v)); }
+
+// 'YYYY-MM' of a UTC instant, and the month before it.
+function monthKey(now) {
+  const d = new Date(num(now));
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`;
+}
+function prevMonth(key) {
+  const [y, m] = str(key).split('-').map(Number);
+  return m === 1 ? `${y - 1}-12` : `${y}-${String(m - 1).padStart(2, '0')}`;
+}
+// How much of this month is gone, counting today as begun: day 1 is 1/31, not 0.
+function monthGone(now) {
+  const d = new Date(num(now));
+  const days = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0)).getUTCDate();
+  return Math.min(1, d.getUTCDate() / days);
+}
+function roundUp(v) { return Math.max(ROUND_USD, Math.ceil(num(v) / ROUND_USD) * ROUND_USD); }
+
+// A budget a person typed → whole dollars, or why not. null clears a pot.
+function parseBudget(raw) {
+  if (raw === null) return { budget: null };
+  const n = Number(raw);
+  if (raw === undefined || raw === '' || !Number.isFinite(n)) return { reason: 'a budget is a number of dollars a month, or null to take the pot away' };
+  if (n <= 0) return { reason: 'a budget is more than $0; send null to take the pot away' };
+  if (n > MAX_BUDGET_USD) return { reason: `a budget is at most $${MAX_BUDGET_USD} a month` };
+  return { budget: Math.round(n * 100) / 100 };
+}
+
+// The spend cap (a project setting; off by default). cap { usd|null, source }.
+function capView(cap, monthUsd) {
+  const usdCap = cap && cap.usd != null && num(cap.usd) > 0 ? round2(cap.usd) : null;
+  if (usdCap == null) return { on: false, usd: null, over: false, source: (cap && cap.source) || 'default', line: 'Off. There is no spend limit unless the project sets one.' };
+  const over = num(monthUsd) >= usdCap;
+  return {
+    on: true, usd: usdCap, over, source: (cap && cap.source) || 'project_settings',
+    line: over ? `On at ${usd(usdCap)} a month, and this month is past it.` : `On at ${usd(usdCap)} a month.`,
+  };
+}
+
+// What a dry pot asks the reserve for: enough to finish the month at its pace.
+function borrowAmount(pot, now) {
+  const have = num(pot.budget_usd) + num(pot.lent_usd);
+  const pace = num(pot.spent_usd) / monthGone(now);
+  return roundUp(Math.max(pace, num(pot.spent_usd)) - have);
+}
+
+// Should this pot file a borrow now? Dry, nothing open, and the treasury has not
+// said no to it this month (a no stands until the month turns).
+function needsBorrow(pot, borrows, month) {
+  if (!pot || !pot.dry) return false;
+  return !(borrows || []).some((b) => String(b.goal_id) === String(pot.goal_id)
+    && (b.state === 'open' || (b.state === 'refused' && b.month === month)));
+}
+
+// The whole treasury, as GET /government/treasury serves it.
+// in: { now, goals: [{ id, title, status }], pots: [{ goal_id, budget_usd, set_at }],
+//       spend: { month_usd, last_month_usd, by_goal: { [goal_id]: usd } },
+//       borrows: [rows of this month, and any still open], cap: { usd, source } }
+function buildTreasury({ now, goals = [], pots = [], spend = {}, borrows = [], cap = null } = {}) {
+  const month = monthKey(now);
+  const monthUsd = round2(spend.month_usd);
+  const lastUsd = round2(spend.last_month_usd);
+  const byGoal = spend.by_goal || {};
+  const open = new Map(goals.filter((g) => g && g.status === 'open').map((g) => [String(g.id), g]));
+  const loans = (borrows || []).map(borrowView);
+  const potRows = (pots || []).filter((p) => p && open.has(String(p.goal_id))).map((p) => {
+    const id = String(p.goal_id);
+    const spent = round2(byGoal[id]);
+    const budget = round2(p.budget_usd);
+    const mine = loans.filter((b) => b.goal_id === id);
+    const lent = round2(mine.filter((b) => b.state === 'lent' && b.month === month).reduce((t, b) => t + num(b.lent_usd), 0));
+    const pot = {
+      goal_id: id, title: str(open.get(id).title), budget_usd: budget, lent_usd: lent, spent_usd: spent,
+      left_usd: round2(budget + lent - spent), dry: spent >= budget + lent,
+      share: monthUsd > 0 ? Math.round((spent / monthUsd) * 10000) / 10000 : 0,
+      set_at: p.set_at instanceof Date ? p.set_at.toISOString() : (p.set_at || null),
+    };
+    // its borrow: the open one, else this month's latest answer
+    const live = mine.find((b) => b.state === 'open') || mine.filter((b) => b.month === month).sort((a, b) => Number(b.id) - Number(a.id))[0] || null;
+    pot.borrow = live;
+    return pot;
+  }).sort((a, b) => (b.dry - a.dry) || (b.spent_usd - a.spent_usd));
+  const given = round2(potRows.reduce((t, p) => t + p.budget_usd, 0));
+  const lentAll = round2(loans.filter((b) => b.state === 'lent' && b.month === month).reduce((t, b) => t + num(b.lent_usd), 0));
+  const reserveUsd = lastUsd > 0 ? round2(lastUsd - given - lentAll) : null;
+  const reserve = {
+    usd: reserveUsd, given_usd: given, lent_usd: lentAll, overdrawn: reserveUsd != null && reserveUsd < 0,
+    line: reserveUsd == null
+      ? 'No month of spend stands behind the reserve yet.'
+      : reserveUsd < 0
+        ? `Overdrawn by ${usd(-reserveUsd)}: work runs on, and the overspend shows as debt.`
+        : `${usd(reserveUsd)} of last month's spend that no pot was given.`,
+  };
+  return {
+    month,
+    cap: capView(cap, monthUsd),
+    spend: { month_usd: monthUsd, last_month_usd: lastUsd },
+    reserve,
+    pots: potRows,
+    basis: 'A pot is a budget its holder gave a goal; its spend is this month\'s real spend on the goal\'s tasks. The reserve is last month\'s real spend that no pot was given, less what it lent.',
+  };
+}
+
+function borrowView(r) {
+  if (!r) return null;
+  const iso = (v) => (v instanceof Date ? v.toISOString() : (v || null));
+  return {
+    id: String(r.id), goal_id: String(r.goal_id), month: str(r.month), matter_id: matterId(r.id),
+    amount_usd: round2(r.amount_usd), budget_usd: round2(r.budget_usd), spent_usd: round2(r.spent_usd),
+    state: str(r.state), lent_usd: r.lent_usd == null ? null : round2(r.lent_usd), answer_key: r.answer_key || null,
+    filed_at: iso(r.filed_at), answered_at: iso(r.answered_at),
+  };
+}
+function matterId(id) { return `${MATTER_SOURCE}:${id}`; }
+
+// The goal as a question can name it: its title when short and plain, else "this goal".
+function goalName(title) {
+  // 'Working area 1 — Project creation' reads as 'Project creation'
+  const t = str(title).replace(/\s+/g, ' ').trim().split(' — ').pop().trim();
+  if (!t || asks.words(t).length > 5 || t.length > 48 || /[?!.:`*#<>[\]]/.test(t)) return 'this goal';
+  return t;
+}
+
+// The borrow ask, in the stored ask shape. Checked by asks.checkAsk before it is
+// returned, so a goal title can never make it slop: an unusable name falls back
+// to "this goal". → the stored ask.
+function borrowAsk({ title, amount_usd, spent_usd, budget_usd, lent_usd = 0, cap = null, month_usd = 0 }) {
+  const amt = Math.round(num(amount_usd));
+  const half = Math.max(1, Math.round(amt / 2));
+  const pastCap = !!(cap && cap.on && num(month_usd) + amt > num(cap.usd));
+  const card = (name) => ({
+    question: `Lend ${name} ${usd(amt)} from the reserve?`,
+    options: [
+      { key: 'lend', label: `Lend ${usd(amt)}`, result: 'The pot refills and work carries on as before.', act: `${ACT_KEY}:lend` },
+      { key: 'half', label: `Lend ${usd(half)}`, result: 'Half now; it asks again if it runs dry.', act: `${ACT_KEY}:half` },
+      { key: 'no', label: 'Say no', result: 'Work still carries on; the overspend shows as debt.', act: `${ACT_KEY}:no` },
+    ],
+    recommend: pastCap
+      ? { key: 'no', why: 'This month is past the spend cap the project set.' }
+      : { key: 'lend', why: 'There is no spend limit, so work runs anyway; lending keeps the books honest.' },
+    waits_on: SEAT,
+    if_nobody_answers: 'Work carries on and the overspend is booked against the reserve.',
+    detail: `${str(title).trim() || 'This goal'}: its pot is dry, ${usd(spent_usd)} spent of ${usd(num(budget_usd) + num(lent_usd))} this month. `
+      + `It asks for ${usd(amt)}, enough to finish the month at its pace.`,
+  });
+  let v = asks.checkAsk(card(goalName(title)));
+  if (!v.ok) v = asks.checkAsk(card('this goal'));
+  if (!v.ok) throw new Error('treasury borrow ask refused: ' + asks.refusalLine(v.errors));
+  return v.ask;
+}
+
+// An answer → what is written: { state, lent_usd, answer_key } or null.
+function answerOf(borrow, key) {
+  if (!borrow || borrow.state !== 'open' || !ANSWERS.includes(key)) return null;
+  const amt = round2(borrow.amount_usd);
+  if (key === 'no') return { state: 'refused', lent_usd: null, answer_key: 'no' };
+  return { state: 'lent', lent_usd: key === 'half' ? Math.max(1, Math.round(amt / 2)) : amt, answer_key: key };
+}
+
+// An open borrow → the docket matter (the treasury_spending source). `acts` only
+// for a viewer who sits in the seat it waits on (canAnswer).
+function borrowMatter(borrow, { title, canAnswer = false } = {}) {
+  const b = borrowView(borrow);
+  const name = str(title).trim() || `goal ${b.goal_id}`;
+  const half = Math.max(1, Math.round(b.amount_usd / 2));
+  return {
+    id: b.id,
+    building: 'treasury',
+    rule: 'decide',
+    state: 'needs',
+    title: `${name}: its pot is dry`,
+    short: `${usd(b.spent_usd)} spent of ${usd(b.budget_usd)}`,
+    where: 'treasury · borrow from the reserve',
+    opened_at: b.filed_at,
+    deadline: null,
+    href: `/goal/${b.goal_id}`,
+    ref: { type: 'pot_borrow', id: b.id },
+    detail: `${name} has spent ${usd(b.spent_usd)} of its ${usd(b.budget_usd)} pot this month and asks the reserve for ${usd(b.amount_usd)}.`,
+    ...(canAnswer ? { acts: [{ key: ACT_KEY, options: [
+      { key: 'lend', label: `Lend ${usd(b.amount_usd)}` }, { key: 'half', label: `Lend ${usd(half)}` }, { key: 'no', label: 'Say no' },
+    ] }] } : {}),
+  };
+}
+
+module.exports = {
+  MATTER_SOURCE, SEAT, ROUND_USD, MAX_BUDGET_USD, ANSWERS, ACT_KEY,
+  monthKey, prevMonth, monthGone, parseBudget, capView, borrowAmount, needsBorrow,
+  buildTreasury, borrowView, matterId, goalName, borrowAsk, answerOf, borrowMatter,
+};

package/modules/hall-ui/public/atlas.html

@@ -92,8 +92,8 @@
 <div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
 
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/craft-mode.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/shell.js?v=2026-10-08-glyph-fix"></script>
+<script src="/builders/craft-mode.js?v=2026-10-09-living3"></script>
+<script src="/builders/shell.js?v=2026-10-10-hall-keys1"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/atlas.js?v=2026-09-02-index" defer></script>

package/modules/hall-ui/public/blockers.html

@@ -51,8 +51,8 @@
 <!-- The app shell (sidebar + top bar). Dependency-free; loaded FIRST so the
      chrome exists before the page script runs. -->
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/craft-mode.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/shell.js?v=2026-10-08-glyph-fix"></script>
+<script src="/builders/craft-mode.js?v=2026-10-09-living3"></script>
+<script src="/builders/shell.js?v=2026-10-10-hall-keys1"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB — rank labels, number formats) + the

package/modules/hall-ui/public/board-room.html

@@ -61,8 +61,8 @@
 <div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
 
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/craft-mode.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/shell.js?v=2026-10-08-glyph-fix"></script>
+<script src="/builders/craft-mode.js?v=2026-10-09-living3"></script>
+<script src="/builders/shell.js?v=2026-10-10-hall-keys1"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/dom-utils.js?v=2026-06-16-board"></script>

package/modules/hall-ui/public/board-room.js

@@ -146,6 +146,8 @@
       return `${escapeHtml(title)} ${pill('quiet', `${matterArea[1]} matter`)}`;
     }
     if (item.subject && item.subject.kind === 'decision_rules') return `Who decides what ${pill('quiet', 'amendment')}`;
+    // task 1004706: a change to the project's laws (enact, repeal, or both)
+    if (item.subject && item.subject.kind === 'laws') return `The project's laws ${pill('quiet', 'law')}`;
     return `Constitutional amendment ${pill('quiet', 'amendment')}`;
   }