@bongos/core 1.21.113 → 1.21.114

package/modules/government/asks.js

@@ -0,0 +1,269 @@
+'use strict';
+
+// modules/government/asks.js — THE ASK: the one shape every request from an AI
+// agent to a person takes (task 1004703, goal 1000111 "government is how a
+// project steers its AI").
+//
+// WHY. The owner's biggest worry: agents "slop" people with run-on text when they
+// need a decision, and a wall of words suppresses the decision. So a blocker, a
+// "please confirm", a review or a sign-off carries an ASK, stored in this shape:
+//
+//   { question:          'Turn unattended building back on?',      // ≤ 12 words, ends '?'
+//     options: [         // 2 or 3 tap answers, each a short label + a one-line result
+//       { key: 'on',  label: 'Turn it on', result: 'Agents build overnight again.', act?: 'go ahead' },
+//       { key: 'off', label: 'Keep it off', result: 'Nothing builds while you sleep.' } ],
+//     recommend:         { key: 'on', why: 'The evaluation passed.' },   // one of the keys, one line
+//     waits_on:          'owner',          // a seat: owner | lead:<b> | committee:<b>.<k> | board:<b>
+//     if_nobody_answers: 'It stays off.',  // one line
+//     detail?:           '…the long text…' }   // rides along; never the ask itself
+//
+// The SERVER REFUSES an ask that breaks the shape and names what to fix
+// (checkAsk → errors[]; refusalLine → one plain paragraph). The rules are the
+// prototype's (modules/hall-ui/public/gov-living.js askFormat, ASK_RULES): the
+// hall's copy and this one are held to the same verdicts, rule by rule, by
+// tests/government_asks.mjs. The server adds what only a STORED ask needs: a
+// seat it can be routed by (task 1004705 routes it), answer keys and acts in a
+// fixed grammar, and caps on every string.
+//
+// WHERE AN ASK LIVES. One row per docket matter, keyed by the matter's docket id
+// (`blockers:12`, `board:34`, `override_requests:5` — docket.js normalizeMatter),
+// in government_asks (government_028). The docket attaches each matter's ask as
+// `ask` (docket.js buildDocket), so every surface reading the docket — the
+// street, the deck, the city — reads the same stored words. Written by POST
+// /blockers (ideas, through the `government` port) and PUT
+// /government/asks/:matter; checked without storing by POST /government/asks/check.
+//
+// PURE: no db, no requires. asks-db.js holds the queries.
+
+// The prototype's rules, number for number (gov-living.js ASK_RULES).
+const ASK_RULES = Object.freeze({ question_words: 12, options_min: 2, options_max: 3, label_words: 4, line_words: 14, why_words: 20 });
+// Caps on characters, so a stored ask can never be a wall in a short coat.
+const CAPS = Object.freeze({ question: 160, label: 40, line: 160, why: 200, detail: 4000 });
+// No markup or links in a line a person reads at a glance (gov-living.js MARKUP).
+const MARKUP = /\*\*|`|^#|\[[^\]]*\]\(|https?:\/\/|<\/?[a-z]/im;
+// Control characters other than tab and line breaks (line breaks have their own rule).
+// eslint-disable-next-line no-control-regex
+const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
+const BUILDINGS = Object.freeze(['charter', 'rules', 'disputes', 'people', 'planning', 'automation', 'review', 'release', 'treasury']);
+// The seats an ask can wait on (gov-living.js seatResolver's grammar). An
+// unseated building falls to the owner when it is routed (owner ruling).
+const SEAT = new RegExp(`^(owner|(lead|board):(${BUILDINGS.join('|')})|committee:(${BUILDINGS.join('|')})\\.[a-z][a-z0-9_]{0,31})$`);
+// An answer's key: what a tap sends. Its act, optional: the matter's own act it
+// takes ('go ahead', 'record', 'force:tested_by_hand'); the deck maps it onto
+// the desk row's real route and refuses one the row does not offer.
+const KEY = /^[a-z][a-z0-9_-]{0,23}$/;
+const ACT = /^[a-z][a-z_ ]{0,31}(:[a-z_]{1,31})?$/;
+// A docket matter's id, as docket.js normalizeMatter writes it: `<source>:<id>`.
+const MATTER_ID = /^[a-z][a-z_]{1,39}:[A-Za-z0-9._-]{1,64}$/;
+const MAX_OPTIONS_READ = 8;
+
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : null);
+function words(text) { return str(text).trim().split(/\s+/).filter(Boolean); }
+
+// Sentences end at . ! ? followed by a space and a capital (or a digit, a quote,
+// a bracket), or by the end; a version (1.20.82) or a decimal does not end one.
+// The hall's own rule, character for character (gov-living.js sentences).
+function sentences(text) {
+  const t = str(text).replace(/\s+/g, ' ').trim();
+  const out = [];
+  let start = 0;
+  for (let i = 0; i < t.length; i++) {
+    const ch = t[i];
+    if (ch !== '.' && ch !== '!' && ch !== '?') continue;
+    const next = t[i + 1];
+    if (next !== undefined && next !== ' ') continue;
+    const after = t[i + 2];
+    if (next === ' ' && after !== undefined && !/[A-Z0-9"'(*[]/.test(after)) continue;
+    out.push(t.slice(start, i + 1).trim());
+    start = i + 2;
+  }
+  if (start < t.length) out.push(t.slice(start).trim());
+  return out.filter((s) => /[A-Za-z0-9]/.test(s));
+}
+
+// checkAsk(raw) → { ok, errors: [{ field, rule, message }], question_words, ask }
+// `ask` is the stored form (trimmed strings, only the known fields) when ok,
+// else null. Every rule that breaks is named, so the agent fixes them all at once.
+function checkAsk(raw) {
+  const errors = [];
+  const err = (field, rule, message) => errors.push({ field, rule, message });
+  const c = obj(raw);
+  if (!c) {
+    err('ask', 'missing', 'Send the ask as a card: a question, two or three answers, a pick, a seat and what happens if nobody answers.');
+    return { ok: false, errors, question_words: 0, ask: null };
+  }
+
+  // ---- the question: the prototype's rules ----
+  const q = str(c.question).trim();
+  const qWords = words(q).length;
+  if (!q) err('question', 'missing', 'Ask one question.');
+  else {
+    if (qWords > ASK_RULES.question_words) err('question', 'too_long', `The question is ${qWords} words; ${ASK_RULES.question_words} at most.`);
+    if (!/\?$/.test(q)) err('question', 'not_a_question', 'End the question with a question mark.');
+    if (sentences(q).length > 1 || /\n/.test(q)) err('question', 'more_than_one', 'Ask exactly one question.');
+    if (MARKUP.test(q)) err('question', 'markup', 'No markup or links in the question.');
+    if (qWords <= ASK_RULES.question_words && (q.length > CAPS.question || CONTROL.test(q))) err('question', 'too_long', `The question is ${q.length} characters; ${CAPS.question} at most.`);
+  }
+
+  // ---- the answers ----
+  const opts = Array.isArray(c.options) ? c.options : [];
+  if (opts.length < ASK_RULES.options_min || opts.length > ASK_RULES.options_max) {
+    err('options', 'count', `Offer ${ASK_RULES.options_min} or ${ASK_RULES.options_max} tap answers, not ${opts.length}.`);
+  }
+  const keys = new Set();
+  const outOpts = [];
+  opts.slice(0, MAX_OPTIONS_READ).forEach((o, i) => {
+    const f = `options[${i}]`;
+    if (!obj(o)) { err(f, 'missing', 'An answer needs a key, a label and a result.'); return; }
+    const k = str(o.key).trim();
+    if (!k) err(f, 'no_key', 'An answer needs a key.');
+    else if (keys.has(k)) err(f, 'duplicate', `Two answers share the key "${k}".`);
+    else if (!KEY.test(k)) err(f, 'bad_key', `The key "${k.slice(0, 30)}" is not one short lower-case word.`);
+    keys.add(k);
+    const label = str(o.label).trim();
+    const lw = words(label).length;
+    if (!lw) err(f, 'no_label', 'An answer needs a label to tap.');
+    else if (lw > ASK_RULES.label_words) err(f, 'label_too_long', `"${label}" is ${lw} words; a tap label is ${ASK_RULES.label_words} at most.`);
+    else if (label.length > CAPS.label || CONTROL.test(label) || /\n/.test(label)) err(f, 'label_too_long', `A tap label is ${CAPS.label} characters at most, on one line.`);
+    lineRule(f + '.result', o.result, 'Say in one line what this answer does.');
+    let act = null;
+    if (o.act != null && o.act !== '') {
+      act = str(o.act).trim();
+      if (!ACT.test(act)) err(f, 'bad_act', 'An answer\'s act names one act of the matter, like "go ahead" or "record".');
+    }
+    outOpts.push({ key: k, label, result: str(o.result).trim(), ...(act ? { act } : {}) });
+  });
+
+  // ---- the pick, and why ----
+  const rec = obj(c.recommend);
+  if (!rec) err('recommend', 'missing', 'Recommend an answer and say why.');
+  else {
+    if (!keys.has(str(rec.key))) err('recommend', 'unknown_key', 'Recommend one of the answers offered.');
+    const why = str(rec.why);
+    const ww = words(why).length;
+    if (!ww) err('recommend', 'no_why', 'Say why in one line.');
+    else if (ww > ASK_RULES.why_words || /\n/.test(why)) err('recommend', 'why_too_long', `The why is ${ww} words; ${ASK_RULES.why_words} at most, one line.`);
+    else if (why.trim().length > CAPS.why || CONTROL.test(why)) err('recommend', 'why_too_long', `The why is ${CAPS.why} characters at most.`);
+  }
+
+  // ---- who it waits on: a seat the direction desk can route ----
+  const seat = str(c.waits_on).trim();
+  if (!seat) err('waits_on', 'missing', 'Say who this waits on.');
+  else if (!SEAT.test(seat)) err('waits_on', 'unknown_seat', `"${seat.slice(0, 40)}" is not a seat: say owner, lead:<building>, committee:<building>.<name> or board:<building>.`);
+
+  // ---- what happens if nobody answers ----
+  lineRule('if_nobody_answers', c.if_nobody_answers, 'Say what happens if nobody answers.');
+
+  // ---- the long text: it may ride along, never as the ask ----
+  const detail = c.detail == null ? '' : (typeof c.detail === 'string' ? c.detail.trim() : null);
+  if (detail === null) err('detail', 'not_text', 'The detail is plain text.');
+  else if (detail.length > CAPS.detail) err('detail', 'too_long', `The detail is ${detail.length} characters; ${CAPS.detail} at most.`);
+
+  const ok = errors.length === 0;
+  return {
+    ok,
+    errors,
+    question_words: qWords,
+    ask: ok ? {
+      question: q,
+      options: outOpts,
+      recommend: { key: str(rec.key), why: str(rec.why).trim() },
+      waits_on: seat,
+      if_nobody_answers: str(c.if_nobody_answers).trim(),
+      detail: detail || null,
+    } : null,
+  };
+
+  function lineRule(field, text, missingMessage) {
+    const t = str(text).trim();
+    const n = words(t).length;
+    if (!n) err(field, 'missing', missingMessage);
+    else if (/\n/.test(t) || n > ASK_RULES.line_words) err(field, 'not_one_line', `${n} words; one line of ${ASK_RULES.line_words} at most.`);
+    else if (MARKUP.test(t)) err(field, 'markup', 'No markup or links.');
+    else if (t.length > CAPS.line || CONTROL.test(t)) err(field, 'not_one_line', `One line of ${CAPS.line} characters at most.`);
+  }
+}
+
+// The refusal, in plain words: what was refused and every fix, in one paragraph.
+function refusalLine(errors) {
+  const list = Array.isArray(errors) ? errors : [];
+  if (!list.length) return '';
+  const fixes = list.slice(0, 8).map((e) => String(e.message || '').trim()).filter(Boolean);
+  const more = list.length > 8 ? ` And ${list.length - 8} more.` : '';
+  return `This ask was refused: a person must be able to answer it at a glance. ${fixes.join(' ')}${more}`;
+}
+
+// task 1004704 — AGENTS WRITE ASKS. When an AI session files a blocker by hand
+// without a card, the route answers this (400 `ask_required`): what to send, in
+// plain words, and the helper that checks a card before filing.
+const ASK_REQUIRED_MESSAGE = 'An AI session files a blocker with an ask: a question of at most '
+  + `${ASK_RULES.question_words} words, ${ASK_RULES.options_min} or ${ASK_RULES.options_max} tap answers each with a one-line result, `
+  + 'a pick and why, who it waits on, and what happens if nobody answers. Put the long text in detail. '
+  + 'Check the card first with: node scripts/gds/ask.js check <file>';
+
+// How a seat reads to a person.
+function seatWords(seat) {
+  const s = str(seat);
+  if (s === 'owner') return 'the owner';
+  const m = /^(lead|board|committee):([a-z]+)(?:\.([a-z0-9_]+))?$/.exec(s);
+  if (!m) return s;
+  const building = m[2].charAt(0).toUpperCase() + m[2].slice(1);
+  if (m[1] === 'lead') return `the ${building} lead`;
+  if (m[1] === 'board') return `the ${building} board`;
+  return `the ${building} ${String(m[3] || '').replace(/_/g, ' ')} committee`;
+}
+
+// cardText(ask) → the card as a person reads it, in plain text: the question,
+// the answers (the pick marked), why, who it waits on, what happens if nobody
+// answers. What an agent prints in chat for anything that is not a stored
+// matter — a "please confirm" at the end of a run, a help request, a review
+// request — so every ask reads the same wherever it lands. `detail` is left out:
+// it rides along, it is never the ask.
+function cardText(ask) {
+  const a = obj(ask);
+  if (!a) return '';
+  const rec = obj(a.recommend) || {};
+  const lines = [str(a.question).trim()];
+  (Array.isArray(a.options) ? a.options : []).forEach((o, i) => {
+    const opt = obj(o) || {};
+    const pick = str(opt.key) && str(opt.key) === str(rec.key) ? ' (recommended)' : '';
+    lines.push(`  ${i + 1}. ${str(opt.label).trim()}${pick}: ${str(opt.result).trim()}`);
+  });
+  if (str(rec.why).trim()) lines.push(`Why: ${str(rec.why).trim()}`);
+  lines.push(`Waits on ${seatWords(a.waits_on)}. If nobody answers: ${str(a.if_nobody_answers).trim()}`);
+  return lines.join('\n');
+}
+
+// A stored row → the ask as every reader gets it (docket matters, blockers).
+function fromRow(row) {
+  if (!row) return null;
+  return {
+    question: row.question,
+    options: Array.isArray(row.options) ? row.options : [],
+    recommend: { key: row.recommend_key, why: row.recommend_why },
+    waits_on: row.waits_on,
+    if_nobody_answers: row.if_nobody_answers,
+    detail: row.detail || null,
+    written_at: row.written_at instanceof Date ? row.written_at.toISOString() : (row.written_at || null),
+  };
+}
+
+function isMatterId(id) { return typeof id === 'string' && MATTER_ID.test(id); }
+
+module.exports = {
+  ASK_RULES,
+  CAPS,
+  BUILDINGS,
+  SEAT,
+  MATTER_ID,
+  ASK_REQUIRED_MESSAGE,
+  checkAsk,
+  refusalLine,
+  cardText,
+  seatWords,
+  fromRow,
+  isMatterId,
+  sentences,
+  words,
+};

package/modules/government/board-idea-reads.js

@@ -0,0 +1,68 @@
+'use strict';
+
+// modules/government/board-idea-reads.js — the board's two reads about a Full
+// Idea: the feedback a returned idea carries back to its author (R13), and
+// whether the board CARRIED it (BV2.R17, task 1004096). Moved out of board.js
+// unchanged (task 1004706) to keep that file under the 1,500-line ratchet;
+// board.js re-exports all three by name, so every caller and the government
+// port read them where they always did. Reads only — db is looked up by property
+// at call time, so a test's monkeypatched db reaches them.
+
+const db = require('./db');
+
+// ── R13's read: the feedback a returned idea carries back to its author ─────
+//
+// One reasoned objection is what returns an idea (§3), so the feedback IS that
+// vote's reason + flagged section, straight off the most recent returned item.
+// Null when this idea has never been returned by the board — the caller (the
+// ideas resubmit path) falls back to the sub-bar weakest-section flag, which is
+// derivable from the stored field_values at any time (R09). Shape mirrors the
+// vote payload so the return flow renders ONE thing for both rejection sources.
+async function latestRejectionForIdea(ideaId) {
+  const id = Number(ideaId);
+  if (!Number.isFinite(id) || id <= 0) return null;
+  const row = await db.getLatestReturnedItemWithObjection('full_idea', id);
+  if (!row) return null;
+  return Object.freeze({
+    source: 'board',
+    item_id: row.item_id,
+    section_key: row.section_key || null,
+    reason_md: row.reason_md || null,
+    closed_at: row.closed_at,
+  });
+}
+
+// ── BV2.R17's read: did the board CARRY this idea? (task 1004096) ───────────
+//
+// The ratification half of the ideator surface turns a Full Idea into a goal,
+// and spec decision 9 is that the ideator RECOMMENDS while the board DECIDES.
+// The ideas module holds the author's recommendation on its own grade row, so
+// without this read "the board decides" would be a sentence in a comment: the
+// only fact stopping a ratification from being one person's opinion is that a
+// sitting actually closed `passed`.
+//
+// Null means "no passing decision on record", which the caller must treat as a
+// refusal and never as an absence it may work around. A returned item, an item
+// still open, and an idea that never reached the board all read the same here,
+// on purpose — none of them is a mandate, and distinguishing them would invite a
+// caller to accept one of them.
+//
+// Frozen, like latestRejectionForIdea, so a caller cannot decorate the record of
+// a decision and pass it on as though the board had said more than it did.
+async function boardPassForIdea(ideaId) {
+  const id = Number(ideaId);
+  if (!Number.isFinite(id) || id <= 0) return null;
+  const row = await db.getLatestPassedItem('full_idea', id);
+  if (!row) return null;
+  return Object.freeze({
+    item_id: row.item_id,
+    outcome: 'passed',
+    opened_at: row.opened_at,
+    closed_at: row.closed_at,
+  });
+}
+
+// boardPassForIdea for a list, in one read (task 1004560).
+const boardPassedIdeaIds = async (ids) => new Set(await db.listPassedSubjectIds('full_idea', ids));
+
+module.exports = { latestRejectionForIdea, boardPassForIdea, boardPassedIdeaIds };

package/modules/government/board.js

@@ -63,6 +63,7 @@ const charter = require('./charter');
 const recommendations = require('./recommendations');
 const decisionRules = require('./decision-rules');
 const decisionBoard = require('./decision-board');
+const lawBoard = require('./law-board');
 
 // ADR 0175 §5: the completeness bar a Full Idea must clear to reach the board.
 // Held equal to economy's IDEA_FULL_PASS_BAR by test — see the header.
@@ -631,11 +632,14 @@ async function closeItem(item, { cause = 'vote' } = {}) {
     : null;
   const rulesAmendment = !!amendment && amendment.kind === 'decision_rules';
   let appliedDecisionRules = null;
+  // task 1004706: a laws amendment is written the same way — inside the close.
+  const lawsAmendment = !!amendment && amendment.kind === 'laws';
+  let appliedLaws = null;
 
   const closed = await db.closeBoardItem({
     itemId: item.id,
     outcome,
-    afterClose: (payMoney || rulesAmendment)
+    afterClose: (payMoney || rulesAmendment || lawsAmendment)
       ? async (client, closedRow) => {
           if (payMoney) {
             credit = await reward.awardIdeaGovernancePassCredit(client, {
@@ -645,6 +649,7 @@ async function closeItem(item, { cause = 'vote' } = {}) {
             });
           }
           if (rulesAmendment) appliedDecisionRules = await decisionBoard.applyPassedDecisionRules(client, closedRow, amendment);
+          if (lawsAmendment) appliedLaws = await lawBoard.applyPassedLaws(client, closedRow, amendment);
         }
       : null,
   });
@@ -664,7 +669,8 @@ async function closeItem(item, { cause = 'vote' } = {}) {
   // failure, never silently absorbed. The apply is re-drivable from the passed
   // item + amendment rows. A returned amendment applies nothing.
   let appliedConstitution = null;
-  if (outcome === 'passed' && closed.subject_type === 'constitutional_amendment' && !rulesAmendment) {
+  // A rules or laws amendment changes its own table, never the board block.
+  if (outcome === 'passed' && closed.subject_type === 'constitutional_amendment' && !rulesAmendment && !lawsAmendment) {
     try {
       if (amendment) {
         appliedConstitution = governmentConfig.applyBoardAmendment(amendment.proposed);
@@ -708,6 +714,7 @@ async function closeItem(item, { cause = 'vote' } = {}) {
     ...(credit ? { credit } : {}),
     ...(appliedConstitution ? { applied_constitution: appliedConstitution } : {}),
     ...(appliedDecisionRules ? { applied_decision_rules: appliedDecisionRules } : {}),
+    ...(appliedLaws ? { applied_laws: appliedLaws } : {}),
     ...(acted ? { acted: acted.result } : {}),
   };
 }
@@ -907,6 +914,10 @@ const withOpenNudge = (fn) => async (args) => {
 };
 const proposeDecisionRules = withOpenNudge((a) => decisionBoard.proposeDecisionRules(a));
 const openMatter = withOpenNudge((a) => decisionBoard.openMatter(a));
+// task 1004711: a Lead's build-out, built at once or filed as a vote (decision-board.js buildOut)
+const buildOut = withOpenNudge((a) => decisionBoard.buildOut(a));
+// task 1004706: the project's laws — an amendment of kind 'laws' (law-board.js).
+const proposeLaws = withOpenNudge((a) => lawBoard.proposeLaws(a));
 
 // ── the board's third subject: closing a genesis stage (task 1004429) ───────
 //
@@ -1293,7 +1304,8 @@ async function constitutionView({ historyLimit = 50, type = null, headcount: ask
     // there is a missed warning rather than a wrong one.
     // Only board-block amendments say what the board block should be (a rules
     // amendment changes the table, task 1004529).
-    divergence: constitutionDivergence(live, history.filter((h) => h.kind !== 'decision_rules')),
+    // Nor do laws amendments (task 1004706): they change the law book.
+    divergence: constitutionDivergence(live, history.filter((h) => h.kind !== 'decision_rules' && h.kind !== 'laws')),
     // Who decides what at each building, as today or set by a passed amendment.
     decision_rules: decisionBoard.constitutionBlock(rulesTable),
     // The genesis charter + legislation stages' payload (task 1004427): every
@@ -1318,60 +1330,8 @@ async function constitutionView({ historyLimit = 50, type = null, headcount: ask
   };
 }
 
-// ── R13's read: the feedback a returned idea carries back to its author ─────
-//
-// One reasoned objection is what returns an idea (§3), so the feedback IS that
-// vote's reason + flagged section, straight off the most recent returned item.
-// Null when this idea has never been returned by the board — the caller (the
-// ideas resubmit path) falls back to the sub-bar weakest-section flag, which is
-// derivable from the stored field_values at any time (R09). Shape mirrors the
-// vote payload so the return flow renders ONE thing for both rejection sources.
-async function latestRejectionForIdea(ideaId) {
-  const id = Number(ideaId);
-  if (!Number.isFinite(id) || id <= 0) return null;
-  const row = await db.getLatestReturnedItemWithObjection('full_idea', id);
-  if (!row) return null;
-  return Object.freeze({
-    source: 'board',
-    item_id: row.item_id,
-    section_key: row.section_key || null,
-    reason_md: row.reason_md || null,
-    closed_at: row.closed_at,
-  });
-}
-
-// ── BV2.R17's read: did the board CARRY this idea? (task 1004096) ───────────
-//
-// The ratification half of the ideator surface turns a Full Idea into a goal,
-// and spec decision 9 is that the ideator RECOMMENDS while the board DECIDES.
-// The ideas module holds the author's recommendation on its own grade row, so
-// without this read "the board decides" would be a sentence in a comment: the
-// only fact stopping a ratification from being one person's opinion is that a
-// sitting actually closed `passed`.
-//
-// Null means "no passing decision on record", which the caller must treat as a
-// refusal and never as an absence it may work around. A returned item, an item
-// still open, and an idea that never reached the board all read the same here,
-// on purpose — none of them is a mandate, and distinguishing them would invite a
-// caller to accept one of them.
-//
-// Frozen, like latestRejectionForIdea, so a caller cannot decorate the record of
-// a decision and pass it on as though the board had said more than it did.
-async function boardPassForIdea(ideaId) {
-  const id = Number(ideaId);
-  if (!Number.isFinite(id) || id <= 0) return null;
-  const row = await db.getLatestPassedItem('full_idea', id);
-  if (!row) return null;
-  return Object.freeze({
-    item_id: row.item_id,
-    outcome: 'passed',
-    opened_at: row.opened_at,
-    closed_at: row.closed_at,
-  });
-}
-
-// boardPassForIdea for a list, in one read (task 1004560).
-const boardPassedIdeaIds = async (ids) => new Set(await db.listPassedSubjectIds('full_idea', ids));
+// ── R13's and BV2.R17's reads about a Full Idea: board-idea-reads.js ───────
+const { latestRejectionForIdea, boardPassForIdea, boardPassedIdeaIds } = require('./board-idea-reads');
 
 // ── the summons: what is waiting on THIS member's vote (task 1003271) ───────
 //
@@ -1456,6 +1416,10 @@ async function pendingVotesFor(builderId) {
 module.exports = {
   proposeDecisionRules,
   openMatter,
+  buildOut,
+  proposeLaws,
+  lawsView: (...a) => lawBoard.lawsView(...a),
+  leadsView: (...a) => decisionBoard.leadsView(...a),
   decisionRulesView: (...a) => decisionBoard.decisionRulesView(...a),
   decisionRulesWriteAllowed: decisionBoard.decisionRulesWriteAllowed,
   applyPassedDecisionRules: decisionBoard.applyPassedDecisionRules,

package/modules/government/build-rights.js

@@ -0,0 +1,148 @@
+'use strict';
+
+// modules/government/build-rights.js — WHO MAY BUILD WITHOUT A VOTE: whether the
+// holder of a building (its Lead, or the owner when it has none) may change the
+// building's structure at once, or must file it as a vote (task 1004710, goal
+// 1000111; ADR 0375).
+//
+// THE OWNER'S RULING (2026-10-09). It comes from the FORM OF GOVERNMENT, and in
+// future will often be shaped by goals. It is NOT a per-Lead flag: a Lead's
+// charter is one line of words (leads.js), and the prototype's
+// `can_build_without_vote` is not stored anywhere.
+//
+// WHAT IS BUILT. A build-out is one of four capsules (the hall's office storey):
+// a committee room, a new floor, an annex, or growing into a district. This file
+// answers, per building and per capsule, { without_vote, why, ground }. Carrying a
+// build-out out is task 1004711; this is the rule it will ask.
+//
+// THE RULE, in the order it is applied (first match decides):
+//   1. A DISTRICT always goes to a vote: it is a new part of the city, not a
+//      change inside one building.                                     ground 'city'
+//   2. A VACANT building (its row says no one holds it) builds nothing.  ground 'building'
+//   3. A GOAL that LIMITS the building: a vote.                          ground 'goal'
+//   4. A building handed to a SITTING of its own (decision-rules.js): under a
+//      rule that lets a seated member act alone ('decide', 'first') the holder
+//      builds at once if that sitting seats them; under any other rule
+//      (consent, majority, unanimous, sign-off) its sitting votes.     ground 'building'
+//   5. A GOAL that GRANTS the building: at once.                         ground 'goal'
+//   6. Otherwise the FORM OF GOVERNMENT answers (FORM_ANSWERS):          ground 'form'
+//        Monarchy / BDFL      at once — the founder decides alone, and whoever
+//                             holds a building acts for them in it.
+//        Timocratic Republic  at once when the holder has earned a vote (sits
+//                             on the board); otherwise a vote.
+//        Direct Democracy     a vote — every builder decides changes together.
+//        Foundation           a vote — the council of trustees decides.
+//        Custom               a vote — settings that match no named form grant
+//                             nothing beyond what they say.
+//   A form that is not available yet (Presidential, Cooperative, Federation)
+//   can never be in force (charter.js refuses it), so it has no answer here.
+//
+// THE GOALS HOOK. `goals` is a list of terms a goal sets on a building:
+//   { goal_id, building: <key> | '*', capsules?: [<capsule>...], allow: bool, why? }
+// A limit (allow false) beats the building's own sitting and the form; a grant
+// (allow true) beats the form only — never a district, a vacant building, or a
+// sitting the project voted in. No goal stores terms yet, so the server passes
+// an empty list today; the hook is here so a goal can grant or limit later
+// without a second rule.
+//
+// FAIL CLOSED. Anything this file cannot read — an unknown form, a missing
+// decision row, a holder nobody can name — answers "a vote", never "at once".
+//
+// PURE: no db. The caller resolves, per request and uncached (ADR 0016), the
+// constitution in force, each building's decision row, and who sits on the
+// board and on each sitting, and hands them in. Requires only charter.js (to
+// name the form from the settings) and decision-rules.js (its rules).
+
+const { readCharter } = require('./charter');
+const { AREA_KEYS, DECISION_RULES } = require('./decision-rules');
+
+// The four build-outs, smallest first; held equal to the hall's CAPSULES
+// (modules/hall-ui/public/street-office.js) by tests/government_build_rights.mjs.
+const CAPSULES = Object.freeze(['committee', 'floor', 'annex', 'district']);
+
+// The documented answer of each form (the table above, as data). `holder`:
+// 'any' builds at once, 'board' builds at once only when the holder sits on the
+// board, 'none' always goes to a vote.
+const FORM_ANSWERS = Object.freeze({
+  monarchy: Object.freeze({ holder: 'any', yes: 'The founder decides alone, so whoever holds this building builds it out at once.' }),
+  'timocratic-republic': Object.freeze({
+    holder: 'board',
+    yes: 'Its holder has earned a vote, so they build it out at once.',
+    no: 'Its holder has not earned a vote yet, so the board votes on it.',
+  }),
+  'direct-democracy': Object.freeze({ holder: 'none', no: 'Every builder decides changes together, so it goes to a vote.' }),
+  foundation: Object.freeze({ holder: 'none', no: 'The council of trustees decides changes, so it goes to a vote.' }),
+  custom: Object.freeze({ holder: 'none', no: 'These settings match no named form, so a change goes to a vote.' }),
+});
+
+const ACTS_ALONE = Object.freeze(DECISION_RULES.filter((r) => r.actsAlone).map((r) => r.key));
+
+const answer = (withoutVote, why, by) => Object.freeze({ without_vote: !!withoutVote, why, ground: by });
+
+// A goal's term matches this building and capsule.
+function termMatches(t, building, capsule) {
+  if (!t || typeof t !== 'object') return false;
+  if (t.building !== '*' && t.building !== building) return false;
+  if (Array.isArray(t.capsules) && t.capsules.length && !t.capsules.includes(capsule)) return false;
+  return typeof t.allow === 'boolean';
+}
+const goalWhy = (t, fallback) => (typeof t.why === 'string' && t.why.trim() ? t.why.trim() : fallback);
+
+// The answer for one capsule at one building.
+//   form      — readCharter(board).form ('monarchy', …, 'custom')
+//   decision  — the building's resolved row (decision-rules.resolveRow), or null
+//   holder    — { seat, on_board: bool, in_sitting: bool }: who holds it, and
+//               whether the board / the building's own sitting seats them
+//   goals     — the goals hook (see above); [] today
+function buildRight({ building, capsule, form, decision, holder, goals = [] } = {}) {
+  if (!AREA_KEYS.includes(building) || !CAPSULES.includes(capsule)) return answer(false, 'This cannot be built.', 'city');
+  if (capsule === 'district') return answer(false, 'A district is a new part of the city, so the board votes on it.', 'city');
+  if (!decision) return answer(false, 'How this building decides could not be read, so it goes to a vote.', 'building');
+  if (decision.rule === 'vacant') return answer(false, 'No one holds this building yet, so nothing is built here.', 'building');
+
+  const terms = Array.isArray(goals) ? goals.filter((t) => termMatches(t, building, capsule)) : [];
+  const limit = terms.find((t) => t.allow === false);
+  if (limit) return answer(false, goalWhy(limit, 'A goal limits building here, so it goes to a vote.'), 'goal');
+
+  const h = holder || {};
+  if (decision.sitting) {
+    const by = `${decision.name} is decided by ${decision.who}`;
+    if (ACTS_ALONE.includes(decision.rule)) {
+      return h.in_sitting
+        ? answer(true, `${by}, and its holder is one of them, so they build it out at once.`, 'building')
+        : answer(false, `${by}, and its holder is not one of them, so it goes to them.`, 'building');
+    }
+    return answer(false, `${by} (${decision.rule_words}), so it goes to them as a vote.`, 'building');
+  }
+
+  const grant = terms.find((t) => t.allow === true);
+  if (grant) return answer(true, goalWhy(grant, 'A goal lets its holder build here at once.'), 'goal');
+
+  const f = FORM_ANSWERS[form] || FORM_ANSWERS.custom;
+  if (f.holder === 'any') return answer(true, f.yes, 'form');
+  if (f.holder === 'board' && h.on_board) return answer(true, f.yes, 'form');
+  return answer(false, f.no, 'form');
+}
+
+// Every capsule at one building: { form, form_name, holder, capsules: { committee: {…}, … } }.
+// `board` is the constitution's board block in force.
+function buildRightsFor({ building, board, decision, holder, goals = [] } = {}) {
+  const read = readCharter(board);
+  const capsules = {};
+  for (const capsule of CAPSULES) {
+    capsules[capsule] = buildRight({ building, capsule, form: read.form, decision, holder, goals });
+  }
+  return Object.freeze({
+    form: read.form,
+    form_name: read.name,
+    holder: holder && holder.seat ? holder.seat : null,
+    capsules: Object.freeze(capsules),
+  });
+}
+
+module.exports = {
+  CAPSULES,
+  FORM_ANSWERS,
+  buildRight,
+  buildRightsFor,
+};