@bongos/core 1.21.8 → 1.21.9

package/modules/government/docket.js

@@ -40,6 +40,15 @@
 // rows — the screen can say a building has matters you cannot see without
 // leaking them.
 //
+// WHO DECIDES, FROM THE TABLE (task 1004529). Every building carries
+// `decision` — who decides it and by which rule — read from the project's
+// decision-rules table (decision-rules.js), so the street and the building
+// interiors state the project's own government rather than a fixed one. A
+// sitting at a building (one of the board's matter subjects) carries the rule it
+// was opened under, which is the table's row at that moment, snapshotted on the
+// item. A contributed matter keeps the rule its own route decides it by: that
+// route's gate is what decides it until its module defers to the row.
+//
 // NOTHING IS INVENTED. A source the design names that has no data yet (grade
 // appeals, votes on new standing rules, the treasury's spending matters) is
 // reported `coming`; a source whose module is off is `off`; a read that throws or
@@ -51,6 +60,7 @@ const board = require('./board');
 const db = require('./db');
 const { resolveBoardMembers } = require('./board-membership');
 const resolver = require('./resolver');
+const decisionRules = require('./decision-rules');
 
 const log = api.logger('government');
 
@@ -214,13 +224,17 @@ function boardMatter(item, { viewerId, members }) {
   else if (voted || memberIds.has(viewer) || authorId === viewer) state = 'moving';
   else state = 'settled';
 
-  const building = item.subject_type === 'full_idea' ? 'planning' : 'charter';
-  const title = item.subject_type === 'constitutional_amendment'
+  const matterArea = decisionRules.areaForSubjectType(item.subject_type);
+  const building = matterArea || (item.subject_type === 'full_idea' ? 'planning' : 'charter');
+  const title = matterArea
+    ? ((item.subject && item.subject.title) || `A matter at ${building}`)
+    : item.subject_type === 'constitutional_amendment'
     ? (item.subject && item.subject.rationale_md ? firstLine(item.subject.rationale_md) : 'A change to the charter')
     : item.subject_type === 'genesis_stage'
       ? `Close the founding stage: ${(item.subject && item.subject.label) || item.subject_id}`
       : ((item.subject && item.subject.title) || `Full idea ${item.subject_id}`);
-  const where = item.subject_type === 'constitutional_amendment' ? 'charter · amendment'
+  const where = matterArea ? `${building} · matter`
+    : item.subject_type === 'constitutional_amendment' ? 'charter · amendment'
     : item.subject_type === 'genesis_stage' ? 'charter · founding'
       : 'planning · idea to ratify';
   const forN = votes.filter((v) => v.direction === 'yes').length;
@@ -233,10 +247,15 @@ function boardMatter(item, { viewerId, members }) {
   return {
     id: item.id,
     building,
-    rule: vocab.PASS_RULE_TO_RULE[constitution.pass_rule] || null,
+    // A building's sitting carries the table's own rule on its snapshot (so a
+    // sign-off reads as sign-off, a one-person decision as decide); every other
+    // sitting reads the board's pass rule.
+    rule: (vocab.RULE_KEYS.includes(constitution.rule) ? constitution.rule : null)
+      || vocab.PASS_RULE_TO_RULE[constitution.pass_rule] || null,
     state,
     title,
-    short: item.subject_type === 'constitutional_amendment' ? 'amendment'
+    short: matterArea ? 'matter'
+      : item.subject_type === 'constitutional_amendment' ? 'amendment'
       : item.subject_type === 'genesis_stage' ? 'founding stage' : 'idea to ratify',
     where,
     opened_at: item.opened_at,
@@ -340,7 +359,10 @@ function registeredContributions() {
 // Build the docket for one viewer. `permissions` is the viewer's resolved set;
 // `contributions` defaults to what is registered on the seam (a test passes its
 // own). Never throws for a source: each is isolated and timed.
-async function buildDocket({ viewer, permissions, contributions = registeredContributions(), now = Date.now(), timeoutMs = SOURCE_TIMEOUT_MS } = {}) {
+// `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 } = {}) {
   const held = new Set(permissions || []);
   const ctx = Object.freeze({
     builderId: String(viewer.id),
@@ -416,9 +438,17 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
   }));
 
   const counts = countStates(matters);
+  const decisionBy = new Map((Array.isArray(decisions) ? decisions : []).filter(Boolean).map((d) => [d.area, d]));
   const buildings = vocab.BUILDINGS.map((b) => {
     const here = matters.filter((m) => m.building === b.key);
-    return { key: b.key, name: b.name, group: b.group, counts: countStates(here), matter_ids: here.map((m) => m.id) };
+    const d = decisionBy.get(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,
+    };
   });
   return {
     viewer: { id: ctx.builderId },
@@ -429,7 +459,11 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
     buildings,
     sources: sourceStatus,
     readings,
-    vocabulary: { buildings: vocab.BUILDINGS, rules: vocab.RULES, states: vocab.STATES },
+    vocabulary: {
+      buildings: vocab.BUILDINGS, rules: vocab.RULES, states: vocab.STATES,
+      // The table's rule set — the matter glyphs plus vacant (no one holds it).
+      decision_rules: decisionRules.DECISION_RULES.map((r) => ({ key: r.key, words: r.words })),
+    },
   };
 }
 
@@ -437,7 +471,13 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
 // uncached — ADR 0016), then build.
 async function docketFor(builder) {
   const permissions = await resolver.resolveBuilderPermissions(builder.id);
-  return buildDocket({ viewer: builder, permissions });
+  // The table is read per request, uncached (ADR 0016). A failed read leaves
+  // every building's decision null; it never fails the city.
+  const decisions = await board.decisionRulesView().catch((err) => {
+    log.warn({ err: err && err.message }, 'governor docket: decision rules unreadable');
+    return null;
+  });
+  return buildDocket({ viewer: builder, permissions, decisions });
 }
 
 module.exports = {

package/modules/government/migrations/government_023_decision_rules.sql

@@ -0,0 +1,190 @@
+-- government_023_decision_rules.sql — who decides what, per building, changed
+-- only by a passed amendment (task 1004529, goal 1000125 the Governor City).
+-- Decision of record: docs/adr/0363-who-decides-what-is-a-table-changed-only-by-amendment.md
+--
+-- WHAT THIS ADDS
+--
+--   1. government_decision_rules — ONE ROW PER BUILDING of the project's
+--      government (charter, rules, disputes, people, planning, automation,
+--      review, release, treasury). Each row says WHO decides matters at that
+--      building and BY WHICH RULE (decide alone, first yes, consent, majority,
+--      unanimous, sign-off, or vacant — nobody holds it yet). An instance is one
+--      project, so the area is the whole key.
+--
+--   2. The nine DEFAULT rows, each meaning "exactly as today": `decided_by =
+--      'gate'` (whoever holds the building's fixed permission acts alone, through
+--      its own page) and, for the charter, `decided_by = 'board'` (the
+--      constitution's own board, under its own pass rule). A default row carries
+--      no rule of its own (rule IS NULL). Seeding them changes NO permission for
+--      any existing project.
+--
+--   3. A GUARD TRIGGER: after the seed, a row may only be changed by a passed
+--      decision-rules amendment. Every insert or update must name the board item
+--      that carried it (`set_by_item_id`), and that item must be a CLOSED, PASSED
+--      constitutional amendment whose amendment row is of kind 'decision_rules'.
+--      There is no settings route that writes this table, and the trigger makes
+--      that structural — a hand-written UPDATE is refused too. Deleting a row is
+--      refused outright. The one exception is re-seeding a MISSING area with its
+--      as-today default, so a re-run of this file stays safe.
+--
+--   4. government_amendments.kind — 'constitution' (every existing row, and the
+--      board block amendments filed today) or 'decision_rules' (a change to rows
+--      of the table above). One amendments table, one subject type, one pass
+--      path: a rules amendment is decided by the board in force exactly like any
+--      other amendment.
+--
+--   5. government_matters + eight new board subjects. Today the board votes on
+--      three things (a Full Idea, a constitutional amendment, a genesis stage).
+--      This adds one subject per building other than the charter — rules_matter,
+--      disputes_matter, people_matter, planning_matter, automation_matter,
+--      review_matter, release_matter, treasury_matter — eleven in all. A matter
+--      is put to a sitting ONLY when its building's row names a sitting (an
+--      amendment moved it off the fixed gate); under the default rows none can
+--      be opened, so nothing about today's behaviour changes.
+--
+-- Additive and idempotent: new tables, a new column with a default every
+-- existing row satisfies, CHECKs that only WIDEN (dropped and re-added under
+-- the same name, the government_020 pattern), and CREATE OR REPLACE for the
+-- trigger function and trigger (Postgres 14+; production runs 16).
+
+BEGIN;
+
+-- ---------------------------------------------------------------------------
+-- 4. amendments gain a kind (first: the guard below reads it).
+-- ---------------------------------------------------------------------------
+ALTER TABLE government_amendments
+  ADD COLUMN IF NOT EXISTS kind text NOT NULL DEFAULT 'constitution';
+
+ALTER TABLE government_amendments
+  DROP CONSTRAINT IF EXISTS government_amendments_kind_check;
+
+ALTER TABLE government_amendments
+  ADD CONSTRAINT government_amendments_kind_check
+  CHECK (kind IN ('constitution', 'decision_rules'));
+
+-- ---------------------------------------------------------------------------
+-- 1. the table
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS government_decision_rules (
+  area            text        PRIMARY KEY
+                  CHECK (area IN ('charter', 'rules', 'disputes', 'people', 'planning',
+                                  'automation', 'review', 'release', 'treasury')),
+  -- 'gate'   — as today: whoever holds the building's fixed permission acts alone
+  -- 'board'  — the constitution's own board (the charter's only value)
+  -- 'nobody' — vacant: no one holds this building yet
+  -- otherwise a board membership predicate (rank:<key>, rank:<key>+, rank:a,b),
+  -- resolved per request and uncached like every other franchise read (ADR 0016).
+  decided_by      text        NOT NULL CHECK (char_length(decided_by) BETWEEN 1 AND 200),
+  rule            text        CHECK (rule IN ('decide', 'first', 'consent', 'majority',
+                                              'unanimous', 'signoff', 'vacant')),
+  -- The design's words for the seat ("Mira under $50, the council above").
+  -- Display only; it never decides anything.
+  who             text        CHECK (who IS NULL OR char_length(who) BETWEEN 1 AND 120),
+  -- The passed amendment's board item that set this row. NULL only on a default.
+  set_by_item_id  bigint      REFERENCES government_board_items(id) ON DELETE RESTRICT,
+  updated_at      timestamptz NOT NULL DEFAULT now(),
+
+  -- A default row carries no rule; every other row carries exactly one.
+  CONSTRAINT government_decision_rules_rule_shape CHECK (
+    (decided_by IN ('gate', 'board') AND rule IS NULL)
+    OR (decided_by = 'nobody' AND rule = 'vacant')
+    OR (decided_by NOT IN ('gate', 'board', 'nobody') AND rule IS NOT NULL AND rule <> 'vacant')
+  ),
+  -- The charter is the board, always: its own rule is changed by amending the
+  -- constitution's board block, never through this table. And only the charter
+  -- may be 'board'.
+  CONSTRAINT government_decision_rules_charter_is_the_board CHECK (
+    (area = 'charter') = (decided_by = 'board')
+  )
+);
+
+-- ---------------------------------------------------------------------------
+-- 2. the defaults — exactly today's behaviour. Inserted BEFORE the guard
+--    exists; on a re-run only a missing area is inserted (and the guard admits
+--    exactly that shape).
+-- ---------------------------------------------------------------------------
+INSERT INTO government_decision_rules (area, decided_by, rule)
+SELECT v.area, v.decided_by, NULL
+  FROM (VALUES
+    ('charter',    'board'),
+    ('rules',      'gate'),
+    ('disputes',   'gate'),
+    ('people',     'gate'),
+    ('planning',   'gate'),
+    ('automation', 'gate'),
+    ('review',     'gate'),
+    ('release',    'gate'),
+    ('treasury',   'gate')
+  ) AS v(area, decided_by)
+ WHERE NOT EXISTS (SELECT 1 FROM government_decision_rules r WHERE r.area = v.area);
+
+-- ---------------------------------------------------------------------------
+-- 3. the guard: changed only by a passed decision-rules amendment.
+-- ---------------------------------------------------------------------------
+CREATE OR REPLACE FUNCTION government_decision_rules_guard() RETURNS trigger
+LANGUAGE plpgsql AS $guard$
+BEGIN
+  IF TG_OP = 'DELETE' THEN
+    RAISE EXCEPTION 'government_decision_rules: a building cannot be removed from the government'
+      USING ERRCODE = 'check_violation';
+  END IF;
+
+  -- Re-seeding a missing area with its as-today default (a re-run of the
+  -- migration). Only on INSERT: an UPDATE back to the default is a change like
+  -- any other and needs its amendment.
+  IF TG_OP = 'INSERT' AND NEW.set_by_item_id IS NULL
+     AND NEW.decided_by IN ('gate', 'board') AND NEW.rule IS NULL THEN
+    RETURN NEW;
+  END IF;
+
+  IF NEW.set_by_item_id IS NULL OR NOT EXISTS (
+       SELECT 1
+         FROM government_board_items i
+         JOIN government_amendments a ON a.id = i.subject_id
+        WHERE i.id = NEW.set_by_item_id
+          AND i.subject_type = 'constitutional_amendment'
+          AND i.outcome = 'passed'
+          AND a.kind = 'decision_rules'
+     ) THEN
+    RAISE EXCEPTION 'government_decision_rules changes only through a passed decision-rules amendment (board item %)', NEW.set_by_item_id
+      USING ERRCODE = 'check_violation';
+  END IF;
+
+  NEW.updated_at := now();
+  RETURN NEW;
+END
+$guard$;
+
+CREATE OR REPLACE TRIGGER government_decision_rules_amendment_only
+  BEFORE INSERT OR UPDATE OR DELETE ON government_decision_rules
+  FOR EACH ROW EXECUTE FUNCTION government_decision_rules_guard();
+
+-- ---------------------------------------------------------------------------
+-- 5. matters, and the eight new subjects
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS government_matters (
+  id           bigserial   PRIMARY KEY,
+  area         text        NOT NULL
+               CHECK (area IN ('rules', 'disputes', 'people', 'planning',
+                               'automation', 'review', 'release', 'treasury')),
+  title        text        NOT NULL CHECK (char_length(btrim(title)) BETWEEN 1 AND 200),
+  detail_md    text        CHECK (detail_md IS NULL OR char_length(detail_md) <= 5000),
+  -- What the building does by itself when the sitting passes, where it can
+  -- (today: People giving or taking a custom rank). NULL = a recorded decision.
+  action       jsonb,
+  proposed_by  bigint      REFERENCES builders(id) ON DELETE SET NULL,
+  created_at   timestamptz NOT NULL DEFAULT now()
+);
+
+ALTER TABLE government_board_items
+  DROP CONSTRAINT IF EXISTS government_board_items_subject_type_check;
+
+ALTER TABLE government_board_items
+  ADD CONSTRAINT government_board_items_subject_type_check
+  CHECK (subject_type IN (
+    'full_idea', 'constitutional_amendment', 'genesis_stage',
+    'rules_matter', 'disputes_matter', 'people_matter', 'planning_matter',
+    'automation_matter', 'review_matter', 'release_matter', 'treasury_matter'
+  ));
+
+COMMIT;

package/modules/government/routes/government.js

@@ -122,6 +122,10 @@ const governmentPort = {
   // `charter` block. Opening a sitting decides nothing; the vote does.
   proposeCharter: board.proposeCharter,
   genesisStageStatus: board.genesisStageStatus,
+  // task 1004529 — who decides what. The table, resolved, and the check a
+  // building's own direct route runs before letting one builder act alone.
+  decisionRulesView: board.decisionRulesView,
+  checkActAlone: board.checkActAlone,
 };
 
 function registerSeams() {
@@ -225,6 +229,31 @@ module.exports = function buildGovernmentRouter() {
     }
     return rank;
   }
+  // WHO DECIDES AT PEOPLE (task 1004529). Giving or taking a custom rank is
+  // People's own act, and the project's decision-rules table says who may do it
+  // alone. As today (the default row) the route's own permission is the whole
+  // gate, unchanged. Once a passed amendment hands People to a sitting, one
+  // builder may no longer do it alone — the route refuses and names the matter
+  // route instead — unless the row's rule lets a seated member decide alone and
+  // this builder is seated. Server-side, per request, uncached (ADR 0016).
+  // Fail-CLOSED: an unreadable row refuses rather than waving the act through.
+  async function peopleMayActAlone(req, res) {
+    let out;
+    try {
+      out = await board.checkActAlone('people', req.builder.id);
+    } catch (err) {
+      log.error('[gds] people decision rule unreadable', err);
+      res.fail('decision_rule_unreadable', { status: 503, message: 'who decides at People could not be read just now' });
+      return false;
+    }
+    if (out.ok) return true;
+    res.fail('decided_by_sitting', 409, {
+      area: out.area, rule: out.rule, who: out.who,
+      what_this_means: out.what_this_means, open_with: out.open_with,
+    });
+    return false;
+  }
+
   const ARCHON = 'archon';
   const ARCHON_REASON = 'the Archon rank holds every permission and is immutable — it is the rank that can never be locked out of this tab (ADR 0172)';
   const ASSIGN_REASON = 'a seeded rank is assigned by rank (R95b sync); change the builder\'s rank instead';
@@ -447,6 +476,7 @@ module.exports = function buildGovernmentRouter() {
     try {
       const rank = await loadAssignableRank(res, rankKey);
       if (rank === null) return;
+      if (!(await peopleMayActAlone(req, res))) return;
       const assigned = await db.assignRank({
         builderId: req.body.builder_id,
         rankKey,
@@ -472,6 +502,7 @@ module.exports = function buildGovernmentRouter() {
     try {
       const rank = await loadAssignableRank(res, rankKey);
       if (rank === null) return;
+      if (!(await peopleMayActAlone(req, res))) return;
       const removed = await db.unassignRank({ builderId, rankKey });
       res.json({ ok: true, builder_id: builderId, rank_key: rankKey, removed });
     } catch (err) {
@@ -678,6 +709,90 @@ module.exports = function buildGovernmentRouter() {
     }
   });
 
+  // rank: perm board.item.open — propose a change to WHO DECIDES WHAT (task
+  // 1004529): one or more buildings' rows of the decision-rules table, filed as
+  // an amendment of kind 'decision_rules' and sat under the constitution IN
+  // FORCE, like every amendment. Nothing here changes the table — only the
+  // sitting passing does, inside its closing transaction. The same atom as
+  // proposing any amendment.
+  //
+  // Body: { rules: [{ area, decided_by, rule?, who? }], rationale_md? }
+  //   area       ∈ rules disputes people planning automation review release treasury
+  //              (the charter is the board — change it with a constitution amendment)
+  //   decided_by 'gate' (as today) | 'nobody' (vacant) | rank:<key> | rank:<key>+ | rank:a,b
+  //   rule       decide | first | consent | majority | unanimous | signoff (vacant with 'nobody';
+  //              none with 'gate')
+  //   who        the seat in words, display only ("Mira under $50, the council above")
+  router.post('/government/board/decision-rules', api.requireBuilder, api.requirePermission('board.item.open'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      rules: { required: true, type: 'array' },
+      rationale_md: { type: 'string', maxLength: 5000 },
+    })) return;
+    try {
+      const out = await board.proposeDecisionRules({
+        rules: req.body.rules,
+        rationaleMd: req.body.rationale_md ?? null,
+        proposedBy: req.builder.id,
+      });
+      if (!out.ok) {
+        if (out.reason === 'no_change') return res.fail('no_change', 409, { reason: 'every building named is already decided this way' });
+        return res.fail('invalid_decision_rules', 400, {
+          reason: out.reason,
+          ...(out.area ? { area: out.area } : {}),
+          ...(out.field ? { field: out.field } : {}),
+          ...(out.expected ? { expected: out.expected } : {}),
+          ...(out.rank_key ? { rank_key: out.rank_key } : {}),
+        });
+      }
+      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, rules: out.rules });
+    } catch (err) {
+      log.error('[gds] POST /government/board/decision-rules', err);
+      res.fail('propose_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  // rank: perm board.item.open — put a MATTER to a building's sitting (task
+  // 1004529): the board's new subjects, one per building other than the
+  // charter. Refused unless the building's row names a sitting — under the
+  // default rows every building is decided as today and this route opens
+  // nothing. The sitting is snapshotted from the row (who and how).
+  //
+  // Body: { area, title, detail_md?, action? }
+  //   action (People only): { type: 'assign_rank' | 'unassign_rank', builder_id, rank_key }
+  //   — carried out when the sitting passes, under the same walls as the direct route.
+  router.post('/government/board/matters', api.requireBuilder, api.requirePermission('board.item.open'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      area: { required: true, type: 'string', maxLength: 32 },
+      title: { required: true, type: 'string', maxLength: 200 },
+      detail_md: { type: 'string', maxLength: 5000 },
+      action: { type: 'object' },
+    })) return;
+    try {
+      const out = await board.openMatter({
+        area: req.body.area,
+        title: req.body.title,
+        detailMd: req.body.detail_md ?? null,
+        action: req.body.action ?? null,
+        proposedBy: req.builder.id,
+      });
+      if (!out.ok) {
+        if (out.reason === 'decided_by_gate' || out.reason === 'no_one_holds_this') {
+          return res.fail(out.reason, 409, { area: out.area, ...(out.gate ? { gate: out.gate } : {}), what_this_means: out.what_this_means });
+        }
+        return res.fail('invalid_matter', 400, {
+          reason: out.reason,
+          ...(out.field ? { field: out.field } : {}),
+          ...(out.expected ? { expected: out.expected } : {}),
+          ...(out.rank_key ? { rank_key: out.rank_key } : {}),
+        });
+      }
+      res.status(201).json({ ok: true, matter: out.matter, item: out.item, decided: out.decided });
+    } catch (err) {
+      log.error('[gds] POST /government/board/matters', err);
+      res.fail('matter_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // rank: perm board.vote.cast — cast a vote on an open board item (R08 of goal
   // 1000069, ADR 0175). The atom FLOORS AT XENOS deliberately (the R04 carry-
   // note): the permission is only the coarse gate, and the real wall is the

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.8",
+  "version": "1.21.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.8",
+      "version": "1.21.9",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.8",
+  "version": "1.21.9",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8804,5 +8804,11 @@
       "id": "1004441",
       "text": "Checked and signed off on the live site: artists and ideators now read as their own craft on profiles, the builders list and the status page. Their earnings charts show, and builders can choose their main role in Settings."
     }
+  ],
+  "1.21.9": [
+    {
+      "id": "1004529",
+      "text": "Each project can now set who decides what in each part of its government: the charter, rules, disputes, people, planning, automation, review, release and treasury. For each part it names who decides and how: one person decides"
+    }
   ]
 }

package/src/bongos/route-rank-check.js

@@ -281,6 +281,12 @@ const GOVERNMENT_PINS = {
   // task 1004523: the governor's docket — every matter awaiting a governor. The
   // coarse gate is the room's; each source inside is scoped to its own atom.
   'GET /government/docket': 'perm:board.vote.cast',
+  // task 1004529: who decides what — a change to the decision-rules table is an
+  // amendment by another door (same atom as proposing one), and a building's
+  // matter is put to its sitting by the same atom. Only a passed amendment
+  // writes the table; neither route does.
+  'POST /government/board/decision-rules': 'perm:board.item.open',
+  'POST /government/board/matters': 'perm:board.item.open',
 };
 
 // Module-scoped privileged-rank pins: a privileged route that lives in a FEATURE

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.8'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.9'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/government_abuse_matrix.mjs

@@ -120,6 +120,9 @@ const stub = {
   unassignRank: async () => true,
   listRanksWithGrants: async () => [],
   listAssignments: async () => [],
+  // task 1004529: People's row is read before a rank is given or taken. No rows
+  // = every building as today, so this matrix's walls are the route's own.
+  listDecisionRules: async () => [],
 };
 const REAL = {};
 for (const k of Object.keys(stub)) {