@bongos/core 1.21.18 → 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-amend.js

@@ -0,0 +1,240 @@
+// modules/hall-ui/public/street-amend.js — CHANGE HOW THIS WORKS: the drafted
+// amendment a building's interior opens (task 1004530, goal 1000125).
+//
+// From any building, "change how this works" drafts an amendment to that
+// building's row of the who-decides-what table (GET /government/constitution →
+// decision_rules.areas[]), prefilled with the rule in force and a proposed one,
+// shown as struck and inserted text. The governor picks who and which rule —
+// from the vocabulary only (the server's rules list and the rank ladder, never
+// free text) — adds a reason, and files it. A filed amendment is a sitting on
+// the Charter, voted through the matter card (street-card.js). There is no
+// settings page: this draft is the only way in, and the board is the only way
+// it takes effect.
+//
+// WHERE IT GOES. A building's row → POST /government/board/decision-rules
+// { rules: [{ area, decided_by, rule }], rationale_md }. The Charter's own row
+// is the board itself, so the Charter's draft is a constitution amendment of
+// the board's members and pass rule → POST /government/board/items (the live
+// board block, those two fields changed). The server's permission checks
+// decide who may file; a refusal is said in plain words (refusal()).
+//
+// THE WORDS. The struck and inserted text is street-card.js's own change() run
+// over the amendment exactly as the server will store it, so the card the
+// council votes on shows the words the governor drafted, by construction.
+//
+// PURE: no DOM, no fetch, no clock. street.js draws what this returns.
+
+(function (root) {
+  'use strict';
+
+  // The standard rank ladder, lowest first (held equal to the server's
+  // membership-predicate RANK_ORDER by test).
+  var RANKS = ['xenos', 'thetes', 'metic', 'archon'];
+  // The table's words for the board's pass rules, and back (decision-rules.js
+  // PASS_RULE_TO_DECISION_RULE).
+  var TO_PASS = { first: 'first_ratifier', consent: 'consent', majority: 'majority', unanimous: 'unanimous' };
+  var FROM_PASS = { first_ratifier: 'first', consent: 'consent', majority: 'majority', unanimous: 'unanimous' };
+  var BOARD_FIELDS = ['membership', 'pass_rule', 'window_minutes', 'close_early_on_full_turnout'];
+  var REASON_MAX = 5000;
+
+  function str(v) { return v == null ? '' : String(v); }
+  function card() { return root.GovMatterCard || null; }
+  function memberWords(p) { var C = card(); return C ? C.memberWords(p) : str(p); }
+  function isPredicate(p) { return /^rank:[a-z0-9,+-]+$/.test(str(p)); }
+
+  function areasOf(constitution) {
+    var d = constitution && constitution.decision_rules;
+    return d && Array.isArray(d.areas) ? d.areas : null;
+  }
+  function vocabOf(constitution) {
+    var d = constitution && constitution.decision_rules;
+    return d && Array.isArray(d.rules) ? d.rules.filter(function (r) { return r && r.key; }) : [];
+  }
+  function rowOf(constitution, area) {
+    var as = areasOf(constitution) || [];
+    for (var i = 0; i < as.length; i++) if (as[i] && as[i].area === area) return as[i];
+    return null;
+  }
+
+  // Who may decide here: as today, the board's own members, a step of the
+  // rank ladder, whoever decides now, or no one. Values only, never free text.
+  function whoOptions(area, row, board) {
+    var out = [], seen = {};
+    function add(value, words) { if (!value || seen[value]) return; seen[value] = true; out.push({ value: value, words: words }); }
+    if (area !== 'charter') add('gate', 'as today: ' + str(row && row.today));
+    if (board && isPredicate(board.membership)) add(board.membership, 'the board: ' + memberWords(board.membership));
+    // the top of the ladder alone is exactly that rank (rank:archon+ is rank:archon)
+    RANKS.forEach(function (k, i) { var v = 'rank:' + k + (i === RANKS.length - 1 ? '' : '+'); add(v, memberWords(v)); });
+    var cur = area === 'charter' ? board && board.membership : row && row.decided_by;
+    if (isPredicate(cur)) add(cur, memberWords(cur));
+    if (area !== 'charter') add('nobody', 'no one: the building stands empty');
+    return out;
+  }
+
+  // Which rules fit who decides: as today decides alone (no rule to pick), no
+  // one is vacant, the charter takes the board's four pass rules, a sitting any
+  // rule but vacant. Drawn from the server's vocabulary only.
+  function ruleOptions(area, decidedBy, vocab) {
+    if (decidedBy === 'gate' || decidedBy === 'nobody') return [];
+    return (vocab || []).filter(function (r) {
+      if (area === 'charter') return Object.prototype.hasOwnProperty.call(TO_PASS, r.key);
+      return r.key !== 'vacant';
+    }).map(function (r) { return { value: r.key, words: str(r.words) }; });
+  }
+  function fixedRule(decidedBy) { return decidedBy === 'gate' ? null : decidedBy === 'nobody' ? 'vacant' : undefined; }
+  function hasValue(list, v) { for (var i = 0; i < list.length; i++) if (list[i].value === v) return true; return false; }
+
+  // The draft for one building, or { ok: false, reason } when the table could
+  // not be read. The proposal starts as the most likely change: a building
+  // decided as today goes to the board's members by consent; one already
+  // changed (or empty) goes back to as today; the charter changes its rule.
+  function draftFor(area, constitution) {
+    if (!areasOf(constitution)) return { ok: false, reason: 'unread' };
+    var row = rowOf(constitution, area);
+    if (!row) return { ok: false, reason: 'unknown_area' };
+    var vocab = vocabOf(constitution);
+    if (!vocab.length) return { ok: false, reason: 'unread' };
+    var board = constitution.board || null;
+    var charter = area === 'charter';
+    if (charter && (!board || !isPredicate(board.membership))) return { ok: false, reason: 'unread' };
+    var d = {
+      ok: true, area: area, name: str(row.name), charter: charter, row: row, board: board, vocab: vocab,
+      current: charter
+        ? { decided_by: board.membership, rule: FROM_PASS[board.pass_rule] || null }
+        : { decided_by: row.decided_by, rule: row.decided_by === 'gate' ? null : row.rule },
+      decided_by: null, rule: null, reason: '',
+    };
+    if (charter) {
+      d.decided_by = board.membership;
+      d.rule = d.current.rule === 'consent' ? 'majority' : 'consent';
+    } else if (row.as_today) {
+      d.decided_by = board && isPredicate(board.membership) ? board.membership : 'rank:metic+';
+      d.rule = 'consent';
+    } else {
+      d.decided_by = 'gate';
+      d.rule = null;
+    }
+    return settle(d);
+  }
+
+  // Keep a draft inside the vocabulary after a pick: the rule follows who.
+  function settle(d) {
+    var who = whoOptions(d.area, d.row, d.board);
+    if (!hasValue(who, d.decided_by)) d.decided_by = who.length ? who[0].value : null;
+    var fixed = fixedRule(d.decided_by);
+    var rules = ruleOptions(d.area, d.decided_by, d.vocab);
+    if (fixed !== undefined) d.rule = fixed;
+    else if (!hasValue(rules, d.rule)) d.rule = hasValue(rules, d.current.rule) ? d.current.rule : rules.length ? rules[0].value : null;
+    d.whoOptions = who;
+    d.ruleOptions = rules;
+    return d;
+  }
+  function copy(d) { var o = {}; for (var k in d) if (Object.prototype.hasOwnProperty.call(d, k)) o[k] = d[k]; return o; }
+
+  // One pick: field 'who' | 'rule' | 'reason'. A value outside the vocabulary
+  // is refused (the draft comes back unchanged).
+  function pick(d, field, value) {
+    if (!d || !d.ok) return d;
+    var n = copy(d);
+    if (field === 'who') { if (!hasValue(d.whoOptions, value)) return d; n.decided_by = value; }
+    else if (field === 'rule') { if (!hasValue(d.ruleOptions, value)) return d; n.rule = value; }
+    else if (field === 'reason') { n.reason = str(value).slice(0, REASON_MAX); return n; }
+    else return d;
+    return settle(n);
+  }
+
+  function changed(d) {
+    return !!(d && d.ok && (d.decided_by !== d.current.decided_by || (d.rule || null) !== (d.current.rule || null)));
+  }
+
+  // The amendment as the server will store it, shaped as a board item, so
+  // street-card.js's change() reads it exactly as the card will.
+  function ruleRow(d) {
+    var r = { area: d.area, decided_by: d.decided_by };
+    if (d.decided_by !== 'gate') r.rule = d.rule;
+    return r;
+  }
+  function proposal(d) {
+    var p = {};
+    BOARD_FIELDS.forEach(function (f) { p[f] = d.board[f] === undefined ? null : d.board[f]; });
+    p.membership = d.decided_by;
+    p.pass_rule = TO_PASS[d.rule] || d.board.pass_rule;
+    if (typeof p.close_early_on_full_turnout !== 'boolean') p.close_early_on_full_turnout = false;
+    return p;
+  }
+  function asItem(d) {
+    if (d.charter) return { subject_type: 'constitutional_amendment', subject: { kind: 'constitution', proposed: proposal(d) } };
+    return { subject_type: 'constitutional_amendment', subject: { kind: 'decision_rules', proposed: { decision_rules: [ruleRow(d)] } } };
+  }
+
+  // The struck and inserted rows: [{ label, struck, inserted }].
+  function change(d) {
+    if (!changed(d)) return [];
+    var C = card();
+    if (!C || !C.change) return [];
+    var docket = { buildings: [{ key: d.area, decision: d.row }] };
+    var ch = C.change(asItem(d), docket, { board: d.board });
+    return ch && Array.isArray(ch.rows) ? ch.rows : [];
+  }
+
+  // Why the draft cannot be filed yet, in words, or '' when it can.
+  function check(d) {
+    if (!d || !d.ok) return 'How this building decides could not be read just now.';
+    if (!changed(d)) return 'That is how it works today. Pick a different way to change it.';
+    if (!str(d.reason).trim()) return 'Say why, so the council knows what it is voting on.';
+    return '';
+  }
+
+  // The request that files it (the server's permission checks decide).
+  function request(d) {
+    if (check(d)) return null;
+    var api = (card() && card().API) || '/api/bongos';
+    var why = str(d.reason).trim();
+    if (d.charter) return { method: 'POST', url: api + '/government/board/items', body: { subject_type: 'constitutional_amendment', proposal: proposal(d), rationale_md: why } };
+    return { method: 'POST', url: api + '/government/board/decision-rules', body: { rules: [ruleRow(d)], rationale_md: why } };
+  }
+
+  // The server's refusal, plainly.
+  var REASONS = {
+    unknown_rank: 'There is no such rank yet, so that would seat no one.',
+    charter_is_the_board: 'The charter is decided by the board itself. Change it from the Charter.',
+    only_the_charter_is_the_board: 'Only the charter is decided by the board.',
+    bad_rule: 'That is not a way this project decides.',
+    bad_decided_by: 'That is not a seat this project knows.',
+    gate_takes_no_rule: 'As today, the building decides alone: there is no rule to pick.',
+    nobody_is_vacant: 'An empty building decides nothing.',
+    bad_membership: 'That is not a seat this project knows.',
+    bad_pass_rule: 'That is not a way the board can decide.',
+  };
+  function refusal(status, body) {
+    var e = body && body.error ? body.error : {};
+    var det = e.details || {};
+    if (e.code === 'proposer_would_lose_their_seat' && det.what_this_means) return str(det.what_this_means);
+    if (e.code === 'no_change') return 'That already is how it works. Nothing was filed.';
+    if (status === 401) return 'Sign in to file an amendment.';
+    if (status === 403) return 'Filing an amendment is not yours to do here. The server refused it.';
+    if ((e.code === 'invalid_decision_rules' || e.code === 'invalid_proposal') && det.reason) {
+      return REASONS[det.reason] || 'The server refused it: ' + str(det.reason).replace(/_/g, ' ') + '.';
+    }
+    var C = card();
+    return C ? C.refusal(status, body) : 'It could not be filed just now.';
+  }
+
+  // What the street says once it is filed, and which sitting to mark.
+  function answer(d, body) {
+    var item = body && body.item;
+    return {
+      toast: 'Filed. Your amendment to ' + (d && d.name ? d.name : 'this building') + ' is on the Charter for the council to vote on.',
+      building: 'charter',
+      matter: item && item.id != null ? 'board:' + item.id : null,
+      kind: 'light',
+    };
+  }
+
+  var api = {
+    RANKS: RANKS, draftFor: draftFor, pick: pick, changed: changed, change: change,
+    check: check, request: request, refusal: refusal, answer: answer, whoOptions: whoOptions, ruleOptions: ruleOptions,
+  };
+  root.GovAmend = api;
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+}(typeof window !== 'undefined' ? window : globalThis));

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

@@ -195,7 +195,8 @@
         return {
           label: BUILDING_NAMES[r.area] || str(r.area),
           struck: today ? [today.who, today.rule_words].filter(Boolean).join(', ') : '',
-          inserted: [r.who || memberWords(r.decided_by), r.rule ? RULE_WORDS[r.rule] || r.rule : (r.decided_by === 'gate' ? 'as today' : '')].filter(Boolean).join(', '),
+          // as today and no one say it all in their seat's words (task 1004530)
+          inserted: [r.who || memberWords(r.decided_by), r.decided_by === 'gate' || r.decided_by === 'nobody' ? '' : r.rule ? RULE_WORDS[r.rule] || r.rule : ''].filter(Boolean).join(', '),
         };
       });
       return rows.length ? { rows: rows } : null;
@@ -691,6 +692,8 @@
     API: API, SECTIONS: SECTIONS, needsRoom: needsRoom, itemIdOf: itemIdOf, subjectKind: subjectKind,
     model: model, request: request, check: check, answer: answer, refusal: refusal, render: render,
     memberWords: memberWords, windowWords: windowWords,
+    // the wording change, for a drafted amendment's struck and inserted text (task 1004530)
+    change: changeOf,
   };
   root.GovMatterCard = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;