@bongos/core 1.19.621 → 1.19.623

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

@@ -0,0 +1,517 @@
+// modules/hall-ui/public/board-room.js — the Board Room (/builders/board-room).
+//
+// The hall's only UPWARD-POINTING gate (ADR 0175): a Full Idea that cleared the
+// completeness grade is ratified here, and the constitution itself is amended
+// here. Nothing else is a board subject.
+//
+// CARVED OUT OF government.js BY ADR 0266. It was the `#board-room` tab of the
+// /government page, which is wrong in two ways the move fixes:
+//   • that page's nav item is labelled "Permissions" and gated archon, so a
+//     Metic who SITS on the board had no door to the room at all;
+//   • the page shell asks `page.view.government` (metic+) while the vote route
+//     asks `board.vote.cast` (floors at XENOS, deliberately, so that widening
+//     the board works). Widen membership below Metic and you get members who
+//     may cast a vote through the API and cannot load the page to cast it on.
+// This page is gated on the vote atom itself (auth.js requireBoardVotePage), so
+// its reach equals the right to vote and widening the board stays a config
+// change — the property ADR 0175 §6 claimed and did not have.
+//
+// DEFENCE IN DEPTH, as everywhere in the hall: the page gate decides who gets
+// the shell and nothing more. `GET /government/board/items` carries the same
+// atom server-side, and MEMBERSHIP is checked in-handler per item against that
+// item's own snapshotted constitution — so a holder who sits on no board sees
+// the room and no ballot. That is the honest state, not a bug: ADR 0175 §9 made
+// the ballot open on purpose, because a board whose votes are invisible
+// constrains nobody.
+//
+// TASK 1003270's two rules came with the card and still govern edits here:
+//   • NO RAW CONFIG KEY REACHES A READER. `first_ratifier` / `rank:archon` /
+//     `why_matters` are grammar for the server; a person gets the sentence
+//     (decidedByHtml, rankNames, SECTION_LABELS). The single exception is a
+//     membership predicate that cannot be PARSED, where the broken string is
+//     the actionable fact.
+//   • COPY THAT EXPLAINS THE UI TO ITSELF IS DELETED, not shortened.
+// What simplifying may NOT touch is ADR 0175 §8: an objection still carries a
+// reason and names one section. That requirement is why voting lives in the
+// hall and not on a chat reaction.
+//
+// ON THE DUPLICATED HELPERS. `pill` / `groupHead` / `when` / `fetchJson` /
+// `sendJson` are per-page in this module by convention (gate.js, harbor.js and
+// watch.js each carry their own — a hall page script is a self-contained IIFE
+// over the DOM). Two are a real drift risk rather than boilerplate and are
+// called out where they sit: `membershipRankKeys` mirrors the SERVER's predicate
+// grammar, and `fmtWindow` is also read by the Constitution panel that stayed in
+// government.js. tests/government_board_vote_ui.mjs holds the first equal to the
+// server; keep the second in step by hand.
+//
+// The function ORDER here is deliberate and matches the pre-carve source:
+// tests/government_board_room_copy.mjs slices this file by function-name
+// landmarks (itemCard → loadBoard, ideaSectionsHtml → rankNames, and so on), so
+// reordering these definitions silently changes what those assertions read.
+
+(() => {
+  'use strict';
+
+  const API = '/api/bongos';
+  // Generated typed client (task 1996 / R09), served as window.BongosClient by
+  // /lib/bongos-client.js. baseUrl:'' passes the full `${API}${path}` URLs below
+  // through unchanged; result-mode ({ status, ok, data }) preserves control flow 1:1.
+  const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
+  const { escapeHtml, fmtInt } = window.OTB;
+  const { emptyStateHtml } = window.OTBKit;
+  const toast = (msg) => window.OTB.toast(msg);
+
+  // ---- fetch helpers (mirror gate.js) --------------------------------------
+
+  async function fetchJson(path) {
+    const res = await api.request('GET', `${API}${path}`);
+    if (res.status === 401) { window.location.assign(`${API}/auth/web/start`); throw { kind: '401' }; }
+    if (res.status === 403) { throw { kind: '403' }; }
+    if (!res.ok) throw new Error(`${path} → ${res.status}`);
+    return res.data;
+  }
+
+  async function sendJson(method, path, body) {
+    const res = await api.request(method, `${API}${path}`, { body: body || {} });
+    if (res.status === 401) { window.location.assign(`${API}/auth/web/start`); throw { kind: '401' }; }
+    const data = res.data || {};
+    if (!res.ok) {
+      const err = data.error || {};
+      throw new Error(err.message && err.message !== err.code ? err.message : friendlyError(err.code) || `${path} → ${res.status}`);
+    }
+    return data;
+  }
+
+  // The vote refusals (R08's route), translated for the person clicking. The
+  // rank/permission-CRUD refusals stayed with the Permissions surface — this page
+  // cannot provoke them.
+  const ERROR_COPY = {
+    not_board_member: 'Only members of this item’s board may vote on it — membership follows the rules that were in force when the window opened.',
+    item_closed: 'This sitting has closed — refreshing.',
+    vote_window_expired: 'This sitting’s clock has run out — the sweep is closing it.',
+    objection_needs_reason: 'An objection must say why — write the reason.',
+    objection_needs_section: 'An objection must point at exactly one section of the idea.',
+    yes_carries_nothing: 'A yes carries no reason or section — those belong to objections.',
+    bad_direction: 'A vote is yes or no — nothing else.',
+    item_not_found: 'That item no longer exists — refreshing.',
+    bad_item_id: 'That item id isn’t valid.',
+  };
+  const friendlyError = (code) => ERROR_COPY[code] || null;
+
+  // ---- shared row pieces ---------------------------------------------------
+
+  // A state pill in the shell's vocabulary. `mod` is one of the .fact-pill
+  // states (ok / warn / danger / info / quiet); the label is what the reader sees.
+  const pill = (mod, label) => `<span class="fact-pill fact-pill--${mod}">${escapeHtml(label)}</span>`;
+  const groupHead = (name, n, note) =>
+    `<div class="ov-group__head"><span class="ov-group__name">${escapeHtml(name)}</span>` +
+    (n === undefined ? '' : `<span class="ov-group__n">${fmtInt(n)}</span>`) +
+    (note ? `<span class="ov-group__note">${escapeHtml(note)}</span>` : '') +
+    '</div>';
+  // A timestamp the way the rows have always shown one: "2026-08-30 14:05".
+  const when = (iso) => escapeHtml(String(iso || '').slice(0, 16).replace('T', ' '));
+
+  // The predicate grammar, in plain language (task 1003094). This MIRRORS
+  // modules/government/membership-predicate.js — browser code cannot import the
+  // server module, the established pattern here (the five section labels do the
+  // same) — and tests/government_board_vote_ui.mjs holds the two equal.
+  //
+  // Rendering the raw predicate was fine while the only form was `rank:<key>`.
+  // It is not fine now: `rank:metic+` would read as "builders holding the metic+
+  // rank", which names a rank that does not exist and hides the very thing the
+  // suffix says.
+  const STANDARD_LADDER = ['xenos', 'thetes', 'metic', 'archon'];
+
+  function membershipRankKeys(predicate) {
+    const m = String(predicate || '');
+    if (!m.startsWith('rank:')) return null;
+    const body = m.slice(5);
+    if (!body) return null;
+    const keys = [];
+    for (const element of body.split(',')) {
+      const match = /^([a-z][a-z0-9_-]*)(\+?)$/.exec(element);
+      if (!match) return null;
+      let expanded;
+      if (match[2] === '+') {
+        const i = STANDARD_LADDER.indexOf(match[1]);
+        if (i === -1) return null;        // "and above" is undefined off the ladder
+        expanded = STANDARD_LADDER.slice(i);
+      } else {
+        expanded = [match[1]];
+      }
+      for (const k of expanded) if (keys.indexOf(k) === -1) keys.push(k);
+    }
+    return keys.length ? keys : null;
+  }
+
+  // ---- the Board Room panel (R16) --------------------------------------------
+
+  // The room renders what the server assembled: open items with the database's
+  // own countdown, the OPEN BALLOT (people, directions, timestamps, objections),
+  // and the closed history.
+
+  function fmtRemaining(seconds) {
+    if (seconds === null || seconds === undefined) return null;
+    const s = Number(seconds);
+    if (!Number.isFinite(s) || s <= 0) return 'closing…';
+    if (s < 90) return `closes in ${Math.max(1, Math.round(s))}s`;
+    if (s < 5400) return `closes in ${Math.round(s / 60)}m`;
+    return `closes in ${(s / 3600).toFixed(1)}h`;
+  }
+
+  function subjectLine(item) {
+    if (item.subject_type === 'full_idea') {
+      const title = item.subject ? item.subject.title : `idea ${item.subject_id}`;
+      return `<a href="/#/idea/${escapeHtml(String(item.subject_id))}">${escapeHtml(title)}</a> ${pill('quiet', 'Full Idea')}`;
+    }
+    return `Constitutional amendment ${pill('quiet', 'amendment')}`;
+  }
+
+  function clockLine(item) {
+    if (item.closes_at) {
+      const rem = fmtRemaining(item.remaining_seconds);
+      return rem || 'timed sitting';
+    }
+    const rule = item.constitution && item.constitution.pass_rule;
+    if (rule === 'first_ratifier') return 'no clock — closes on the first vote';
+    // A clockless majority sitting is worth naming honestly: without a deadline
+    // it waits indefinitely for a majority, which is a real state a project can
+    // configure itself into (task 1003273).
+    if (rule === 'majority') return 'no clock — waits for a majority';
+    // Same honesty for unanimity: with no deadline it waits indefinitely for
+    // someone to be in favour, which is a state a project can configure (ADR 0267).
+    if (rule === 'unanimous') return 'no clock — waits for a unanimous yes';
+    return 'no clock';
+  }
+
+  // The open ballot: one voter, one dense row — who, then the direction pill
+  // and the time as facts, and an objection's section and reason as the sub line.
+  function ballotHtml(item, viewerId) {
+    if (!item.votes.length) {
+      return emptyStateHtml(`No votes yet${item.closed_at ? '. Closed unopposed' : ''}.`);
+    }
+    const rows = item.votes.map((v) => {
+      const who = escapeHtml(v.display_name || v.github_login || `builder ${v.voter_id}`);
+      const mine = String(v.voter_id) === String(viewerId) ? ' <span class="gov-held-note">your vote</span>' : '';
+      // Task 1003270: the faulted section by its LABEL — the words the author
+      // wrote under and the objector picked from. `why_matters` is a jsonb key,
+      // not something a reader should have to decode.
+      const objection = v.direction === 'no'
+        ? `<p class="ov-row__sub">objected to <strong>${escapeHtml(SECTION_LABELS[v.section_key] || v.section_key || 'the idea')}</strong>: ${escapeHtml(v.reason_md || '')}</p>`
+        : '';
+      return `<li class="ov-row ov-row--dense"><div class="ov-row__main">
+        <span class="ov-row__title">${who}${mine}</span>
+        ${objection}
+        <div class="ov-row__facts">${v.direction === 'no' ? pill('danger', 'objected') : pill('ok', 'yes')}<span class="ov-row__when">${when(v.cast_at)}</span></div>
+      </div></li>`;
+    }).join('');
+    return `<ul class="ov-rows">${rows}</ul>`;
+  }
+
+  // ---- the vote form (R17) -----------------------------------------------------
+
+  // The five section labels, mirrored from the base template declaration
+  // (modules/ideas/templates.js — the words the author saw when writing; a test
+  // holds the two equal, since browser code cannot import a server module).
+  const SECTION_LABELS = {
+    purpose: 'Purpose of Idea',
+    big_picture: 'What does the Big Picture look like',
+    why_had: 'Why did you have the Idea',
+    why_matters: 'Why does the Idea Matter',
+    fit: 'How does the Idea Fit into the big picture of the project',
+  };
+
+  // The idea's five sections, IN FRONT of the voter — the entire reason voting
+  // happens in the hall rather than on a reaction. Rendered in template order.
+  //
+  // TASK 1003270 — OPEN, AND SET AS PROSE. This used to be a <details> summarised
+  // "The idea, in full · completeness 100/100": the substance the vote is about
+  // sat behind a click while the constitutional metadata above it stayed expanded,
+  // which is exactly backwards. The labels were <code> pills over
+  // `.gov-perm__guards`, so an author's answers were styled as config rows. The
+  // score moved into the collapsed metadata (decidedByHtml) — it describes the
+  // grade the idea cleared, not the idea.
+  function ideaSectionsHtml(item) {
+    const fv = item.subject && item.subject.field_values;
+    if (!fv) return '';
+    const rows = Object.keys(SECTION_LABELS).map((key) => {
+      // An unanswered section is dropped rather than rendered as a bare heading:
+      // a graded Full Idea has all five, and a blank one is only noise.
+      const body = String(fv[key] ?? '').trim();
+      if (!body) return '';
+      return `<h4 class="ov-prose__l">${escapeHtml(SECTION_LABELS[key])}</h4>
+        <p class="ov-prose__p gov-idea__body">${escapeHtml(body)}</p>`;
+    }).join('');
+    return rows
+      ? `<div class="ov-prose gov-idea">${rows}</div>`
+      : emptyStateHtml('This idea has no written sections.');
+  }
+
+  // ---- the sitting's rules, in plain words (task 1003270) --------------------
+
+  // The card used to carry `tally: 0 yes · 0 no — sitting under <first_ratifier>,
+  // membership <rank:archon>` — raw config keys, in a reader's face, ABOVE the
+  // idea they were being asked to decide. These say the same thing in the words
+  // a person thinks in, filed under a summary where secondary information
+  // belongs.
+  //
+  // Read from the item's SNAPSHOT constitution (the rules in force when the
+  // window opened), never today's config — the same rules the server tallies
+  // under. Rank KEYS never surface: the display label comes from the branding
+  // pack via OTB.rankLabel, as on every other hall surface. The one place a raw
+  // predicate still shows is an UNREADABLE one, where the broken string is the
+  // actionable fact and hiding it would help nobody.
+  function rankNames(keys) {
+    const labels = keys.map((k) => escapeHtml(window.OTB.rankLabel(k)));
+    if (labels.length === 1) return labels[0];
+    return `${labels.slice(0, -1).join(', ')} or ${labels[labels.length - 1]}`;
+  }
+
+  // A sitting length in the unit a person would say it in. The config stores
+  // minutes; "2880 minutes" is a number nobody converts in their head.
+  //
+  // DUPLICATED, KNOWINGLY: government.js keeps its own copy for the Constitution
+  // panel's windowSentence. Two readers, two files, one wording — if you change
+  // the phrasing here, change it there.
+  function fmtWindow(minutes) {
+    const m = Number(minutes);
+    if (!Number.isFinite(m) || m <= 0) return `${escapeHtml(String(minutes))} minutes`;
+    const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+    if (m % 1440 === 0) return plural(m / 1440, 'day');
+    if (m % 60 === 0) return plural(m / 60, 'hour');
+    return plural(m, 'minute');
+  }
+
+  const PASS_RULE_PLAIN = {
+    first_ratifier: 'The first vote decides it: a yes ratifies, an objection returns it to its author.',
+    consent: 'It passes unless someone objects — silence is agreement, and one reasoned objection returns it.',
+    majority: 'It passes only when more than half the board votes yes. Silence is not agreement here.',
+    unanimous: 'Everyone who votes must vote yes, and at least one member must. One objection sends it back for revision.',
+  };
+
+  function decidedByHtml(item) {
+    const c = item.constitution || {};
+    const past = !!item.closed_at;
+    const keys = membershipRankKeys(c.membership);
+    const who = keys
+      ? `Every active <strong>${rankNames(keys)}</strong> ${past ? 'could vote on this' : 'may vote on this'}.`
+      : `Nobody ${past ? 'could vote' : 'may vote'} — the membership setting <code>${escapeHtml(String(c.membership || 'unset'))}</code> cannot be read.`;
+    const rule = PASS_RULE_PLAIN[c.pass_rule] || 'How this sitting passes could not be read.';
+    const clock = c.window_minutes === null || c.window_minutes === undefined
+      ? `No deadline — it ${past ? 'stayed' : 'stays'} open until a vote decides it.`
+      : `The sitting ${past ? 'ran' : 'runs'} ${fmtWindow(c.window_minutes)}${c.close_early_on_full_turnout ? ', closing early once every member has voted' : ''}.`;
+    const score = item.subject ? item.subject.completeness_score : null;
+    const grade = score == null
+      ? ''
+      : `<p class="gov-grid-note">It cleared the completeness grade at ${escapeHtml(String(score))}/100.</p>`;
+    return `<p class="gov-grid-note">${who}</p>
+      <p class="gov-grid-note">${rule}</p>
+      <p class="gov-grid-note">${clock}</p>${grade}`;
+  }
+
+  // TASK 1003270: the ballot is the point of the card, so its copy earns its
+  // place or goes. What stayed is the ADR 0175 §8 requirement itself — an
+  // objection carries a REASON and names ONE SECTION — because that requirement
+  // is the whole reason voting lives in the hall instead of on a chat reaction.
+  // Simplifying may not weaken it, so the reason box and the five-way picker are
+  // untouched; only the sentences around them shrank.
+  function voteFormHtml(item, viewerId) {
+    if (item.closed_at) return '';
+    const mine = item.votes.find((v) => String(v.voter_id) === String(viewerId));
+    if (mine) return '';
+    // TASK 1003273: the author gets a REAL ballot. The old branch returned a note
+    // and no form, which is what made the Board Room show nine sittings and no
+    // way to vote on any of them — every one of them was the reader's own. They
+    // may now cast; what they cannot do is decide alone (the close trigger needs
+    // a voice that is not theirs, and a majority made only of them cannot carry).
+    // The note says so instead of refusing, so the limit is visible rather than
+    // discovered by clicking.
+    const isOwnIdea = item.subject_type === 'full_idea'
+      && item.subject && String(item.subject.author_id) === String(viewerId);
+    const sections = Object.keys(SECTION_LABELS).map((key) => `
+      <label class="gov-vote__section"><input type="radio" name="vote-section-${escapeHtml(item.id)}" value="${escapeHtml(key)}"> <span>${escapeHtml(SECTION_LABELS[key])}</span></label>`).join('');
+    const ownNote = isOwnIdea
+      ? `<p class="gov-grid-note">Your own idea. You may vote, but it can’t be decided by your vote alone, and a vote on your own idea earns no karma.</p>`
+      : '';
+    return `<div class="gov-vote" data-item="${escapeHtml(item.id)}">
+      ${ownNote}
+      <button type="button" class="btn-accent" data-vote="yes">Vote yes</button>
+      <details class="gov-vote__no">
+        <summary class="btn-ghost">Object…</summary>
+        <p class="gov-grid-note">This sends the idea back to its author. Say why, and which section.</p>
+        <textarea data-vote-reason placeholder="Why — the reason the author will act on" maxlength="5000" rows="3"></textarea>
+        <div class="gov-vote__sections">${sections}</div>
+        <button type="button" class="btn-ghost btn-ghost--danger" data-vote="no">Cast objection</button>
+      </details>
+    </div>`;
+  }
+
+  async function castVoteFromRoom(itemId, direction, container) {
+    const body = { direction };
+    if (direction === 'no') {
+      const reason = (container.querySelector('[data-vote-reason]') || {}).value || '';
+      const picked = container.querySelector(`input[name="vote-section-${itemId}"]:checked`);
+      body.reason_md = reason;
+      if (picked) body.section_key = picked.value;
+    }
+    try {
+      const out = await sendJson('POST', `/government/board/items/${encodeURIComponent(itemId)}/votes`, body);
+      toast(out.item_closed
+        ? `Vote cast — the sitting closed: ${out.outcome}.`
+        : 'Vote cast.');
+    } catch (err) {
+      if (err && err.kind === '401') return;
+      toast(`Could not vote: ${err.message || err}`);
+    }
+    loadBoard(); // re-render either way — the room shows what stands
+  }
+
+  // ONE SITTING, ONE DECISION (task 1003270). The card reads top-down in the
+  // order a person actually needs it:
+  //
+  //   1. what is being decided — the idea's TITLE, at title size. It used to
+  //      render through `.gov-section__head`, i.e. 11.5px uppercase letterspaced:
+  //      the subject of the vote styled as a table header.
+  //   2. the ACTION, immediately under it. Everything that used to sit between
+  //      the two — a tally of raw config keys, a sentence explaining that the UI
+  //      had no vote form (it does), and a collapsed idea — is gone or moved, so
+  //      "Vote yes" lands above the fold on an ordinary window instead of below
+  //      a wall of prose.
+  //   3. the idea itself, open (ideaSectionsHtml).
+  //   4. the constitutional metadata, collapsed — who votes, how it passes, the
+  //      clock, and the open ballot. Still one click away, never invisible: the
+  //      tally rides the summary, which is the part of it a reader scans for
+  //      (ADR 0175 §9 — a board whose votes are invisible constrains nobody).
+  //
+  // A CLOSED sitting has no action and no idea body: its head carries the
+  // outcome and the record lives under the same summary.
+  //
+  // In v3 a sitting IS the panel (task 1003469): the card is the shell's .scroll,
+  // its title the panel's display-voice heading.
+  function itemCard(item, viewerId) {
+    const yes = item.votes.filter((v) => v.direction === 'yes').length;
+    const no = item.votes.filter((v) => v.direction === 'no').length;
+    const isOpen = !item.closed_at;
+    const state = isOpen
+      ? `${pill('info', 'open')} <span>${escapeHtml(clockLine(item))}</span>`
+      : (item.outcome === 'passed' ? pill('ok', item.outcome) : pill('warn', item.outcome || ''));
+    const amendmentDetail = item.subject_type === 'constitutional_amendment' && item.subject
+      ? `<p class="gov-item__amend">Proposes <code>${escapeHtml(JSON.stringify(item.subject.proposed))}</code>${item.subject.rationale_md ? ` — ${escapeHtml(item.subject.rationale_md)}` : ''}</p>`
+      : '';
+    const mine = item.votes.find((v) => String(v.voter_id) === String(viewerId));
+    // A voter who has cast sees WHAT they cast where the buttons were. The line
+    // that used to fill this slot for everyone else — announcing that the reader
+    // had not voted and that casting was still to come — is deleted outright: it
+    // explained the UI to itself, and the form it promised shipped in R17.
+    const action = !isOpen ? ''
+      : mine
+        ? `<p class="gov-item__cast">You ${mine.direction === 'no' ? 'objected' : 'voted yes'}. One vote per member.</p>`
+        : voteFormHtml(item, viewerId);
+    const tally = `${yes} yes · ${no} objection${no === 1 ? '' : 's'}`;
+    return `<section class="scroll gov-item" id="board-item-${escapeHtml(item.id)}">
+      <div class="gov-item__head">
+        <h3 class="gov-item__title">${subjectLine(item)}</h3>
+        <span class="gov-item__state">${state}</span>
+      </div>
+      ${amendmentDetail}
+      ${action ? `<div class="gov-item__act">${action}</div>` : ''}
+      ${isOpen ? ideaSectionsHtml(item) : ''}
+      <details class="gov-item__meta">
+        <summary class="gov-item__summary">${tally} · who votes, and how it ${isOpen ? 'passes' : 'passed'}</summary>
+        <div class="gov-item__metabody">
+          ${decidedByHtml(item)}
+          ${ballotHtml(item, viewerId)}
+        </div>
+      </details>
+    </section>`;
+  }
+
+  async function loadBoard() {
+    const box = document.getElementById('gov-board');
+    let data;
+    try {
+      data = await fetchJson('/government/board/items');
+    } catch (err) {
+      if (err && err.kind === '401') return;
+      if (err && err.kind === '403') { showSealed(); return; }
+      box.innerHTML = emptyStateHtml('Could not load the Board Room just now.');
+      return;
+    }
+    const viewerId = data.viewer_id;
+    const openItems = data.open || [];
+    const closedItems = data.closed || [];
+    const open = openItems.map((i) => itemCard(i, viewerId)).join('');
+    const closed = closedItems.map((i) => itemCard(i, viewerId)).join('');
+    box.innerHTML =
+      (open || `<section class="scroll">${emptyStateHtml('Nothing is before the board. When a Full Idea clears the completeness grade, its window opens here.')}</section>`)
+      + `<div class="gov-board__divider">${groupHead('Closed sittings', closedItems.length)}</div>`
+      + (closed || `<section class="scroll">${emptyStateHtml('No sitting has closed yet.')}</section>`);
+    // The subtitle counts what is actually waiting, so the room says on arrival
+    // what the nav badge said from outside it (ADR 0266).
+    const sub = document.getElementById('board-sub');
+    if (sub) {
+      sub.textContent = openItems.length
+        ? `${openItems.length} open ${openItems.length === 1 ? 'sitting' : 'sittings'}.`
+        : 'Nothing is before the board.';
+    }
+    // R21: the Discord announcement deep-links ?item=<id> — land the reader on
+    // THAT sitting. It carried `#board-room` too while this was a tab; the hash
+    // is now meaningless here and government.js redirects the old form (ADR
+    // 0266). A missing or unknown id is simply the room as usual. The mark is
+    // the world's lit grammar: the accent, and only on the one live thing.
+    const wanted = new URLSearchParams(window.location.search).get('item');
+    if (wanted) {
+      const el = document.getElementById(`board-item-${wanted}`);
+      if (el) {
+        el.scrollIntoView({ block: 'start' });
+        el.style.outline = '2px solid var(--accent)';
+        el.style.outlineOffset = '2px';
+      }
+    }
+    // R17: the cast buttons. One delegated listener; the SERVER refuses every
+    // illegitimate cast regardless (membership, anti-self, closed, expired) —
+    // the form is a courtesy, the route is the wall.
+    box.querySelectorAll('.gov-vote [data-vote]').forEach((btn) => {
+      btn.addEventListener('click', () => {
+        const wrap = btn.closest('.gov-vote');
+        btn.disabled = true;
+        castVoteFromRoom(wrap.dataset.item, btn.dataset.vote, wrap);
+      });
+    });
+  }
+
+  // ---- init ----------------------------------------------------------------
+
+  // Unlike its neighbours in the Government group, the seal here is NOT a rank
+  // notice. The page's atom (`board.vote.cast`) floors at xenos, so a visitor who
+  // reaches this state is one the permission was withheld from rather than one
+  // standing below a rung — saying "available from Trusted up" would be a guess
+  // and usually a wrong one (ADR 0266).
+  function showSealed() {
+    document.getElementById('board-sealed').hidden = false;
+    document.getElementById('board-body').hidden = true;
+    document.getElementById('board-sub').textContent = 'Restricted.';
+    const body = document.getElementById('board-sealed-body');
+    if (body) {
+      body.textContent = 'The Board Room is open to the builders this project’s constitution seats on its board.';
+    }
+  }
+
+  async function init() {
+    // The page gate already decided this visitor may be here; the /me read is
+    // for the 403 courtesy only, exactly as on the other government surfaces.
+    try {
+      await fetchJson('/me');
+    } catch (err) {
+      if (err && err.kind === '401') return;
+      if (err && err.kind === '403') { showSealed(); return; }
+      // Any other failure is not an authorization answer — show the room and let
+      // the board read speak for itself.
+    }
+    document.getElementById('board-sub').textContent = 'Loading sittings…';
+    document.getElementById('board-body').hidden = false;
+    loadBoard();
+  }
+
+  init();
+})();

package/modules/hall-ui/public/board-room.states.json

@@ -0,0 +1,104 @@
+{
+  "_": "Board Room — the sittings, the ballot and the vote form, carved out of the /government tab strip onto its own page by ADR 0266. Unlike its neighbours in the Government group this page is gated on the `board.vote.cast` atom (xenos floor) rather than page.view.government, so the sealed state here means the permission was withheld, not that the reader stands below a rung.",
+  "page": "/builders/board-room",
+  "surface": "hall-ui",
+  "stub": {
+    "prefix": "/builders/"
+  },
+  "modeQuery": false,
+  "_feeds": "The kit's own stub carries no feed for this page, so against it the page renders its EMPTY and SKELETON states — which is the point: those are states the floors must hold in. Against the hall-preview harness the same states render populated. Every declared 404 below is a fixture the harness does not carry, named rather than hidden.",
+  "ignoreRequests": [
+    "/api/(gds|bongos)/me$",
+    "/api/(gds|bongos)/me/",
+    "/api/(gds|bongos)/goals",
+    "/api/(gds|bongos)/inbox/",
+    "/api/(gds|bongos)/versions",
+    "/api/(gds|bongos)/government"
+  ],
+  "ignoreConsole": [
+    "/api/(gds|bongos)/",
+    "\\b401\\b",
+    "\\b403\\b",
+    "\\b404\\b",
+    "\\b501\\b",
+    "Unauthorized",
+    "Forbidden",
+    "Not Found",
+    "Not Implemented",
+    "load failed"
+  ],
+  "states": {
+    "room": {
+      "auth": true,
+      "actions": [
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#board-body",
+          "#gov-board"
+        ]
+      }
+    },
+    "out": {
+      "auth": false
+    },
+    "sitting-meta": {
+      "auth": true,
+      "actions": [
+        [
+          "wait",
+          600
+        ],
+        [
+          "click",
+          ".gov-item__summary"
+        ],
+        [
+          "wait",
+          300
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#gov-board"
+        ]
+      }
+    },
+    "objection-form": {
+      "auth": true,
+      "actions": [
+        [
+          "wait",
+          600
+        ],
+        [
+          "click",
+          ".gov-vote__no > summary"
+        ],
+        [
+          "wait",
+          300
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#gov-board"
+        ]
+      }
+    }
+  },
+  "reducedMotion": {
+    "auth": true,
+    "actions": [
+      [
+        "wait",
+        600
+      ]
+    ]
+  },
+  "_states": "The room itself, plus the two disclosures a sitting card carries — the collapsed constitutional metadata (`.gov-item__summary`, where ADR 0175 §9's tally and open ballot live) and the objection form (`.gov-vote__no`, whose open state takes the full row and is the widest thing on the page). Both are measured because both were the states the pre-carve page never rendered against a fixture. A state whose click target is absent — no open sitting in the feed — still measures the room, which is the honest empty floor."
+}