@bongos/core 1.21.34 → 1.21.36

package/modules/autonomy/governor-docket.js

@@ -52,9 +52,63 @@ function fenceDocketMatters(project, mayManage) {
     tally: null,
     href: '/watch',
     ref: { type: 'autonomy_fence', id: 'project' },
+    // The floor desk's acts (task 1004559), only for the switch's own atom.
+    ...(mayManage ? { acts: project.enabled === false ? [{ key: 'switch_on' }] : [{ key: 'allow', pick: 'open_goals', except: [] }, { key: 'switch_off', options: OFF_REASONS }] } : {}),
   }];
 }
 
+// Why the switch goes off, as one tap (POST /autonomy/fence takes a reason).
+const OFF_REASONS = Object.freeze([
+  { key: 'pause', label: 'pause for now' },
+  { key: 'cost', label: 'spending too much' },
+  { key: 'quality', label: 'builds look wrong' },
+]);
+// Why one runner is paused, as one tap (POST /autonomy/builders/:id/pause).
+const PAUSE_REASONS = Object.freeze([
+  { key: 'pause', label: 'pause for now' },
+  { key: 'cost', label: 'spending too much' },
+  { key: 'stuck', label: 'it is stuck' },
+]);
+
+// The Automation desks (task 1004559): rows the holder of autonomy.fence.manage
+// acts on in place. Pure; exported for tests.
+// The switch when it is on and has goals (otherwise the fence matter carries it).
+function switchDeskRows(project) {
+  const goals = Array.isArray(project && project.goals) ? project.goals : [];
+  if (!project || project.enabled === false || !goals.length) return [];
+  return [{ id: 'switch', name: 'The switch', fact: `on · ${goals.length} ${goals.length === 1 ? 'goal' : 'goals'}`, facts: ['unattended building is on'], opened_at: project.updated_at || null, ref: { type: 'autonomy_fence', id: 'project' }, acts: [{ key: 'switch_off', options: OFF_REASONS }] }];
+}
+// One row per allowed goal (first in line, or not allowed any more), and one to
+// allow another of the open goals the screen already reads.
+function goalDeskRows(project) {
+  const goals = Array.isArray(project && project.goals) ? project.goals : [];
+  const first = project && project.priority_goal_id != null ? Number(project.priority_goal_id) : null;
+  const rows = goals.map((g) => {
+    const isFirst = first === Number(g.goal_id);
+    return {
+      id: g.goal_id, name: `goal ${g.goal_id}`, fact: isFirst ? 'first in line' : g.added_at ? `allowed ${dayWord(g.added_at)}` : 'allowed',
+      facts: isFirst ? ['the runner works it first'] : [], opened_at: g.added_at || null,
+      ref: { type: 'autonomy_goal', id: g.goal_id },
+      acts: isFirst ? [{ key: 'disallow' }] : [{ key: 'first' }, { key: 'disallow' }],
+    };
+  });
+  rows.push({ id: 'add', tool: true, name: 'Allow a goal', fact: goals.length ? `${goals.length} allowed now` : 'none allowed yet', ref: { type: 'autonomy_goal', id: 'add' }, acts: [{ key: 'allow', pick: 'open_goals', except: goals.map((g) => g.goal_id) }] });
+  return rows;
+}
+// One row per builder with a runner (or a pause on record): pause or resume it.
+function runnerDeskRows(scopes, nowMs, describe) {
+  return (scopes || []).filter((b) => (b.runners || []).length || b.owner_paused).map((b) => {
+    const live = (b.runners || []).map((r) => ({ r, h: describe(r, { nowMs }) })).find((x) => x.h && x.h.ok && x.h.state !== 'never_seen');
+    const fact = b.owner_paused ? 'paused' : live && live.r.working_task_id ? `on task ${live.r.working_task_id}` : live ? 'idle' : 'not seen lately';
+    return {
+      id: b.builder_id, name: b.display_name || b.github_login || `builder ${b.builder_id}`, fact,
+      facts: b.owner_paused && b.owner_paused_reason ? [b.owner_paused_reason] : [],
+      ref: { type: 'autonomy_runner', id: b.builder_id },
+      acts: b.owner_paused ? [{ key: 'resume' }] : [{ key: 'pause', options: PAUSE_REASONS }],
+    };
+  });
+}
+
 // Money left under the unattended-spend ceiling. Pure. Hot when under a fifth left.
 function moneyReading({ ceilingUsd, spentUsd }) {
   const ceiling = Number(ceilingUsd) || 0;
@@ -147,6 +201,8 @@ function fenceHistory(project) {
 const shared = (once, key, fn) => (typeof once === 'function' ? once(key, fn) : fn());
 const spendFor = (reward, once) => shared(once, 'autonomy.spendMtd', () => reward.autonomousApiSpendMtd());
 const fenceFor = (once) => shared(once, 'autonomy.fence', () => db.readFence());
+// The Running now floor and the runners desk read the same rows once per request.
+const runnersFor = (once) => shared(once, 'autonomy.runners', () => db.readAllRunnerScopes());
 
 function contributeAutonomyFloors() {
   api.contribute(POINT, {
@@ -156,7 +212,7 @@ function contributeAutonomyFloors() {
   // GET /autonomy/runners/all is the owner's read of every runner.
   api.contribute(POINT, {
     floor: 'automation.running', gate: { permission: 'autonomy.fence.manage' },
-    read: async (_ctx, { now } = {}) => runningFloor(await db.readAllRunnerScopes(), now || Date.now(), runnerHealth.describeRunner),
+    read: async (_ctx, { now, once } = {}) => runningFloor(await runnersFor(once), now || Date.now(), runnerHealth.describeRunner),
   });
   api.contribute(POINT, {
     floor: 'automation.spending_limit', gate: { permission: 'autonomy.precheck' },
@@ -176,8 +232,16 @@ function contributeAutonomyFloors() {
   });
 }
 
+function contributeAutonomyDesks() {
+  const gate = { permission: 'autonomy.fence.manage' };
+  api.contribute(POINT, { desk: 'automation.switch', gate, read: async (_ctx, { once } = {}) => { const p = await fenceFor(once); if (!p) throw new Error('fence_uninitialised'); return switchDeskRows(p); } });
+  api.contribute(POINT, { desk: 'automation.goals', gate, read: async (_ctx, { once } = {}) => { const p = await fenceFor(once); if (!p) throw new Error('fence_uninitialised'); return goalDeskRows(p); } });
+  api.contribute(POINT, { desk: 'automation.runners', gate, read: async (_ctx, { now, once } = {}) => runnerDeskRows(await runnersFor(once), now || Date.now(), runnerHealth.describeRunner) });
+}
+
 function contributeAutonomyToDocket() {
   contributeAutonomyFloors();
+  contributeAutonomyDesks();
   // GET /autonomy/fence is any builder's read; the read itself fails on a missing
   // fence row rather than fabricating "off" (that route's rule).
   api.contribute(POINT, {
@@ -206,6 +270,9 @@ function contributeAutonomyToDocket() {
 module.exports = {
   contributeAutonomyToDocket,
   fenceDocketMatters,
+  switchDeskRows,
+  goalDeskRows,
+  runnerDeskRows,
   moneyReading,
   allowedGoalsFloor,
   runningFloor,

package/modules/autonomy/matter-acts.js

@@ -0,0 +1,41 @@
+'use strict';
+
+// modules/autonomy/matter-acts.js — what a PASSED Automation matter carries out
+// (task 1004561, goal 1000125). When a project's decision table puts Automation
+// to a sitting, the sitting's passed matter acts here, after the close commits:
+// the switch on or off, or one goal allowed. Each act goes through the SAME db
+// function its direct route calls (POST /autonomy/fence, POST
+// /autonomy/fence/goals), so a matter can do nothing the route could not.
+// The government module only checks the act's shape and calls in through the
+// 'governor.matterAct' contribution point (a module never requires a sibling).
+
+const api = require('../../src/module-api');
+const db = require('./db');
+
+const log = api.logger('autonomy');
+const POINT = 'governor.matterAct';
+
+const why = (ctx) => `a passed Automation matter (matter ${ctx && ctx.matterId})`;
+
+async function switchFence(enabled, ctx) {
+  const row = await db.setFenceEnabled({ enabled, reason: why(ctx), builderId: ctx.decidedBy });
+  if (!row) return { done: false, reason: 'fence_uninitialised' };
+  log.info(`[gds] autonomy fence ${enabled ? 'ENABLED' : 'DISABLED'} by ${why(ctx)}, proposed by builder ${ctx.decidedBy}`);
+  return { done: true };
+}
+
+const ACTS = Object.freeze({
+  switch_on: (_action, ctx) => switchFence(true, ctx),
+  switch_off: (_action, ctx) => switchFence(false, ctx),
+  allow_goal: async (action, ctx) => {
+    await db.allowGoal({ goalId: action.goal_id, note: why(ctx), builderId: ctx.decidedBy });
+    log.info(`[gds] autonomy fence: goal ${action.goal_id} ALLOWED by ${why(ctx)}`);
+    return { done: true };
+  },
+});
+
+function contributeAutomationMatterActs() {
+  for (const [type, act] of Object.entries(ACTS)) api.contribute(POINT, { area: 'automation', type, act });
+}
+
+module.exports = { ACTS, contributeAutomationMatterActs };

package/modules/autonomy/routes/autonomy.js

@@ -108,6 +108,8 @@ const governorDocket = require('../governor-docket');
 
 module.exports = function buildAutonomyRouter() {
   governorDocket.contributeAutonomyToDocket();
+  // what a passed Automation matter carries out (task 1004561)
+  require('../matter-acts').contributeAutomationMatterActs();
   const router = express.Router();
 
   // The one Discord line for a runner idle on a setting (task 1004539). The port

package/modules/government/board.js

@@ -1370,6 +1370,9 @@ async function boardPassForIdea(ideaId) {
   });
 }
 
+// boardPassForIdea for a list, in one read (task 1004560).
+const boardPassedIdeaIds = async (ids) => new Set(await db.listPassedSubjectIds('full_idea', ids));
+
 // ── the summons: what is waiting on THIS member's vote (task 1003271) ───────
 //
 // THE PROBLEM THIS EXISTS TO FIX. Nine items sat open for two days with zero
@@ -1485,6 +1488,7 @@ module.exports = {
   maybeCloseAfterVote,
   latestRejectionForIdea,
   boardPassForIdea,
+  boardPassedIdeaIds,
   validateProposedConstitution,
   proposeAmendment,
   boardRoomView,

package/modules/government/db.js

@@ -712,6 +712,19 @@ async function getLatestPassedItem(subjectType, subjectId) {
   return rows[0] || null;
 }
 
+// Which of these subjects the board passed, in ONE read (task 1004560: the
+// Ideas-to-ratify desk asks for every open Full Idea at once).
+async function listPassedSubjectIds(subjectType, subjectIds) {
+  const ids = (subjectIds || []).map(Number).filter((n) => Number.isInteger(n) && n > 0);
+  if (!ids.length) return [];
+  const { rows } = await pool.query(
+    `SELECT DISTINCT subject_id FROM government_board_items
+      WHERE subject_type = $1 AND subject_id = ANY($2::bigint[]) AND outcome = 'passed'`,
+    [subjectType, ids],
+  );
+  return rows.map((r) => String(r.subject_id));
+}
+
 // The expiry sweep's read (R11): every OPEN item whose deadline has passed, on
 // the database clock, oldest deadline first. Served by the partial index
 // government_board_items_open_by_deadline (government_003 built it for exactly
@@ -872,6 +885,7 @@ module.exports = {
   getExpiredOpenBoardItems,
   getLatestReturnedItemWithObjection,
   getLatestPassedItem,
+  listPassedSubjectIds,
   createAmendment,
   getAmendment,
   listDecisionRules,

package/modules/government/decision-board.js

@@ -50,7 +50,9 @@ async function applyPassedDecisionRules(client, closedRow, amendment) {
 }
 
 // A passed matter: act where the building can act by itself, and build the
-// announcement. Never throws — the decision already stands.
+// announcement. Never throws — the decision already stands. Runs after the
+// close commits (People since task 1004529; Automation, Release, Review and
+// Treasury since task 1004561, through their owning modules' acts).
 async function actOnPassedMatter(closed) {
   const area = decisionRules.areaForSubjectType(closed.subject_type);
   let matter = null;
@@ -71,11 +73,30 @@ async function actOnPassedMatter(closed) {
         await db.unassignRank({ builderId: action.builder_id, rankKey: action.rank_key });
         result = { ...result, action: action.type, done: true, builder_id: String(action.builder_id), rank_key: action.rank_key };
       }
+    } else if (area !== 'people' && action && MATTER_ACTIONS[area]) {
+      // The owning module carries it out, through its direct route's own
+      // function (task 1004561). Re-validated first: the stored row was checked
+      // when opened and is immutable since, so a refusal means it was altered.
+      const v = validateMatterAction(area, action);
+      const doer = v.ok ? matterActFor(area, v.action.type) : null;
+      if (!v.ok) {
+        result = { ...result, action: action.type || null, done: false, reason: 'bad_action' };
+      } else if (!doer) {
+        result = { ...result, action: v.action.type, done: false, reason: 'not_wired' };
+      } else {
+        const out = (await doer.act(v.action, { decidedBy: matter.proposed_by, matterId: String(matter.id) })) || {};
+        result = { ...result, action: v.action.type, done: out.done === true, ...(out.reason ? { reason: String(out.reason) } : {}) };
+      }
     }
   } catch (err) {
     log.error(`[government] matter ${closed.subject_id} passed at ${area} but its act did NOT run (re-drivable from the passed item): ${err && err.message}`);
     result = { ...result, done: false, reason: 'act_failed' };
   }
+  // A refusal (already decided elsewhere, the module off) leaves the decision
+  // standing; it is said loudly here and carried as `acted: false`.
+  if (result.action && !result.done && result.reason !== 'act_failed') {
+    log.warn(`[government] matter ${closed.subject_id} passed at ${area} but its act was refused: ${result.reason || 'not done'}`);
+  }
   return {
     result,
     payload: {
@@ -153,22 +174,74 @@ async function decisionRulesView() {
 // the whole point — People decided by a council's consent sits as exactly that.
 const MATTER_TITLE_MAX = 200;
 const MATTER_DETAIL_MAX = 5000;
-const MATTER_ACTION_TYPES = Object.freeze(['assign_rank', 'unassign_rank']);
+// What a passed matter may carry out, per building (task 1004561). People acts
+// here, in this module; every other act is carried out by the module that owns
+// the building's direct route, through the same function that route calls,
+// contributed to 'governor.matterAct' as { area, type, act }. This table is only
+// the SHAPE of each act (field → kind), checked when the matter is opened and
+// again before it acts. 'id' is a positive integer, 'rank' a custom rank key,
+// 'usd' a non-negative amount or null (no limit).
+const MATTER_ACTIONS = Object.freeze({
+  people: Object.freeze({
+    assign_rank: Object.freeze({ builder_id: 'id', rank_key: 'rank' }),
+    unassign_rank: Object.freeze({ builder_id: 'id', rank_key: 'rank' }),
+  }),
+  automation: Object.freeze({
+    switch_on: Object.freeze({}),
+    switch_off: Object.freeze({}),
+    allow_goal: Object.freeze({ goal_id: 'id' }),
+  }),
+  release: Object.freeze({
+    approve_override: Object.freeze({ request_id: 'id' }),
+    approve_gate: Object.freeze({ pr: 'id' }),
+  }),
+  review: Object.freeze({
+    satisfy_criterion: Object.freeze({ criterion_id: 'id' }),
+  }),
+  treasury: Object.freeze({
+    set_budget: Object.freeze({ builder_id: 'id', monthly_usd: 'usd' }),
+  }),
+});
+const MATTER_ACT_POINT = 'governor.matterAct';
+const MAX_BUDGET_USD = 100000;
+
+function fieldValue(kind, raw) {
+  if (kind === 'id') {
+    const n = Number(raw);
+    return Number.isSafeInteger(n) && n > 0 && raw !== null && raw !== '' && typeof raw !== 'boolean' ? { ok: true, v: n } : { ok: false };
+  }
+  if (kind === 'rank') return typeof raw === 'string' && /^[a-z][a-z0-9-]*$/.test(raw) && raw.length <= 64 ? { ok: true, v: raw } : { ok: false };
+  if (kind === 'usd') {
+    if (raw === null) return { ok: true, v: null };
+    return typeof raw === 'number' && Number.isFinite(raw) && raw >= 0 && raw <= MAX_BUDGET_USD ? { ok: true, v: raw } : { ok: false };
+  }
+  return { ok: false };
+}
 
 function validateMatterAction(area, action) {
   if (action == null) return { ok: true, action: null };
-  if (area !== 'people') return { ok: false, reason: 'action_not_supported_here', expected: 'only People can act by itself today (assign_rank / unassign_rank)' };
+  const acts = MATTER_ACTIONS[area];
+  if (!acts) return { ok: false, reason: 'action_not_supported_here', expected: `a matter acts by itself only at ${Object.keys(MATTER_ACTIONS).join(', ')}` };
   if (typeof action !== 'object' || Array.isArray(action)) return { ok: false, reason: 'bad_action' };
+  const shape = acts[action.type];
+  if (!shape) return { ok: false, reason: 'bad_action', expected: Object.keys(acts) };
   for (const k of Object.keys(action)) {
-    if (!['type', 'builder_id', 'rank_key'].includes(k)) return { ok: false, reason: 'unknown_field', field: `action.${k}` };
+    if (k !== 'type' && !Object.prototype.hasOwnProperty.call(shape, k)) return { ok: false, reason: 'unknown_field', field: `action.${k}` };
   }
-  if (!MATTER_ACTION_TYPES.includes(action.type)) return { ok: false, reason: 'bad_action', expected: MATTER_ACTION_TYPES };
-  const builderId = Number(action.builder_id);
-  if (!Number.isInteger(builderId) || builderId <= 0) return { ok: false, reason: 'bad_action', field: 'action.builder_id' };
-  if (typeof action.rank_key !== 'string' || !/^[a-z][a-z0-9-]*$/.test(action.rank_key) || action.rank_key.length > 64) {
-    return { ok: false, reason: 'bad_action', field: 'action.rank_key' };
+  const out = { type: action.type };
+  for (const [k, kind] of Object.entries(shape)) {
+    if (!Object.prototype.hasOwnProperty.call(action, k)) return { ok: false, reason: 'bad_action', field: `action.${k}` };
+    const f = fieldValue(kind, action[k]);
+    if (!f.ok) return { ok: false, reason: 'bad_action', field: `action.${k}` };
+    out[k] = f.v;
   }
-  return { ok: true, action: { type: action.type, builder_id: builderId, rank_key: action.rank_key } };
+  return { ok: true, action: out };
+}
+
+// The owning module's act for (area, type), or null when that module is off.
+function matterActFor(area, type) {
+  return api.contributions(MATTER_ACT_POINT)
+    .find((c) => c && c.area === area && c.type === type && typeof c.act === 'function') || null;
 }
 
 async function openMatter({ area, title, detailMd = null, action = null, proposedBy } = {}) {
@@ -190,7 +263,10 @@ async function openMatter({ area, title, detailMd = null, action = null, propose
     };
   }
   if (!resolved.sitting) return { ok: false, reason: 'no_one_holds_this', area, what_this_means: `No one holds ${resolved.name} yet, so nothing there can be decided.` };
-  if (a.action) {
+  if (a.action && area !== 'people' && !matterActFor(area, a.action.type)) {
+    return { ok: false, reason: 'action_not_wired', area, what_this_means: `Nothing at ${resolved.name} can carry that out right now, so it would pass and do nothing. Turn on the module that owns ${resolved.name}, or file the matter without an act.` };
+  }
+  if (a.action && area === 'people') {
     const rank = await db.getRankByKey(a.action.rank_key);
     if (!rank) return { ok: false, reason: 'unknown_rank', rank_key: a.action.rank_key };
     if (rank.is_system) return { ok: false, reason: 'seeded_rank', rank_key: a.action.rank_key, expected: 'a custom rank — a seeded rank follows the builder\'s rank' };
@@ -295,6 +371,9 @@ module.exports = {
   proposeDecisionRules,
   decisionRulesView,
   validateMatterAction,
+  matterActFor,
+  MATTER_ACTIONS,
+  MATTER_ACT_POINT,
   openMatter,
   checkActAlone,
 };

package/modules/government/docket-floors.js

@@ -215,7 +215,27 @@ function governmentHistory(gov) {
   return out;
 }
 
+// The People desk's rank rows (task 1004559): one row per custom rank, to give it
+// (POST /government/assignments) or take it back (DELETE
+// /government/assignments/:builderId/:rankKey), each a chip per person (at most
+// five). Seeded ranks are tiers, set on the builder's own row. Pure.
+function rankDeskRows(ranks, assignments) {
+  const people = new Map();
+  for (const a of assignments || []) if (!people.has(String(a.builder_id))) people.set(String(a.builder_id), a.display_name || a.github_login || `builder ${a.builder_id}`);
+  return (ranks || []).filter((r) => r && !r.is_system).map((r) => {
+    const holders = (assignments || []).filter((a) => a.rank_key === r.rank_key);
+    const held = new Set(holders.map((a) => String(a.builder_id)));
+    const give = [...people].filter(([id]) => !held.has(id)).slice(0, 5).map(([id, name]) => ({ key: id, label: name }));
+    const take = holders.slice(0, 5).map((a) => ({ key: String(a.builder_id), label: people.get(String(a.builder_id)) }));
+    const acts = [];
+    if (give.length) acts.push({ key: 'give', options: give });
+    if (take.length) acts.push({ key: 'take', options: take });
+    return { id: r.rank_key, name: r.label || 'unnamed rank', fact: `${holders.length} ${holders.length === 1 ? 'holds it' : 'hold it'}`, facts: r.description ? [r.description] : [], ref: { type: 'custom_rank', id: r.rank_key }, acts };
+  });
+}
+
 module.exports = {
+  rankDeskRows,
   BUILDERS,
   ideasFloor,
   governmentHistory,

package/modules/government/docket-vocab.js

@@ -90,6 +90,24 @@ const FLOORS = Object.freeze([
   ['treasury.rewards', 'treasury'], ['treasury.grading', 'treasury'], ['treasury.hosting', 'treasury'],
 ].map(([key, building]) => Object.freeze({ key, building })));
 
+// The floor desks' own rows (task 1004559): things on a floor a viewer may act on
+// in place that are not matters waiting on anyone: a builder's tier, an allowed
+// goal, a runner, a confirmed report waiting for its fix. Each is read by the
+// module that owns its write route, under that route's atom; a desk whose module
+// is off reports `off` and the floor shows its quiet line.
+const DESKS = Object.freeze([
+  ['people.builders', 'people'], ['people.ranks', 'people'],
+  ['disputes.confirmed', 'disputes'],
+  ['automation.switch', 'automation'], ['automation.goals', 'automation'], ['automation.runners', 'automation'],
+  ['people.invite', 'people'], ['release.core', 'release'],
+  ['rules.settings', 'rules'], ['rules.modules', 'rules'], ['treasury.backup', 'treasury'],
+  // the Planning desks (task 1004560): the goals in their worked order, and the
+  // ideas a ratifier may take from here
+  ['planning.order', 'planning'], ['planning.ratify', 'planning'],
+  // task 1004561: a builder's monthly spending limit, and a sign-off undone
+  ['treasury.budgets', 'treasury'], ['review.signed', 'review'],
+].map(([key, building]) => Object.freeze({ key, building })));
+
 module.exports = {
   BUILDINGS,
   BUILDING_KEYS,
@@ -99,4 +117,5 @@ module.exports = {
   STATES,
   READINGS,
   FLOORS,
+  DESKS,
 };

package/modules/government/docket.js

@@ -35,6 +35,15 @@
 //   { history: 'releases', building: 'release', gate: …,   // the record drawers
 //     read: async (ctx) => [{ id, title, at, outcome }, …] }
 //
+//   { desk: 'people.builders', gate: …,              // one of docket-vocab DESKS
+//     read: async (ctx) => [{ id, name, fact, facts, acts, ref, tool? }, …] }
+//
+// A DESK (task 1004559) is the rows a floor desk acts on in place that are not
+// matters: a builder's tier, an allowed goal, a runner. A matter or a desk row
+// may carry `acts`, the acts THIS viewer may take, decided by the owning module
+// from ctx.has() with its write route's own atom (normalizeActs below). Desk
+// rows never reach the street's pins or counts.
+//
 // 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,
@@ -117,6 +126,7 @@ const COMING_FLOORS = Object.freeze([
 ]);
 const MAX_FLOOR_LINES = 6;
 const MAX_HISTORY_PER_SOURCE = 60;
+const MAX_DESK_ROWS = 40;
 
 
 // A source read that has not answered by now is reported unavailable rather than
@@ -172,9 +182,88 @@ function normalizeMatter(raw, { source, building }) {
     tally: tally(raw.tally),
     href: raw.href ? String(raw.href) : null,
     ref: raw.ref && typeof raw.ref === 'object' ? { type: String(raw.ref.type), id: String(raw.ref.id) } : null,
+    ...actsField(raw.acts),
   };
 }
 
+// WHAT A VIEWER MAY DO, FROM THE SERVER (task 1004559). A matter or a desk row may
+// carry `acts`: the acts THIS viewer may take on it, decided by the owning module
+// from ctx.has() with the same atom its own write route checks. The floor desk
+// draws one button per act (at most two) and one-tap chips for an act's options;
+// the route still decides (the docket only hides what would be refused). An act
+// is { key, options?: [{ key, label }], pick?: 'open_goals', except?: [id] }:
+// `pick` asks the screen to offer the open goals it already reads, minus
+// `except`. Pure. Anything malformed is dropped, never guessed.
+const MAX_ACTS = 2;
+const MAX_OPTIONS = 5;
+const ACT_KEY_RE = /^[a-z][a-z_]{1,23}$/;
+const PICKS = Object.freeze(['open_goals']);
+// The one thing a desk may type: a GitHub name to invite (it is a name, not a
+// reason; reasons stay chips).
+const FIELDS = Object.freeze(['github_login']);
+function normalizeActs(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((a) => a && typeof a === 'object' && ACT_KEY_RE.test(String(a.key))).slice(0, MAX_ACTS).map((a) => {
+    const out = { key: String(a.key) };
+    const options = (Array.isArray(a.options) ? a.options : [])
+      .filter((o) => o && o.key != null && o.label != null && String(o.label).trim())
+      .slice(0, MAX_OPTIONS)
+      .map((o) => ({ key: String(o.key).slice(0, 64), label: String(o.label).slice(0, 16) }));
+    if (options.length) out.options = options;
+    if (PICKS.includes(a.pick)) {
+      out.pick = a.pick;
+      out.except = (Array.isArray(a.except) ? a.except : []).map(String).slice(0, 200);
+    }
+    if (FIELDS.includes(a.field)) out.field = a.field;
+    return out;
+  });
+}
+function actsField(raw) {
+  const acts = normalizeActs(raw);
+  return acts.length ? { acts } : {};
+}
+
+// One desk row as a contributor handed it (task 1004559). A desk row is a thing on
+// a floor a viewer may act on that is not a matter waiting on anyone: a builder
+// whose tier can be set, an allowed goal, a runner, a confirmed report waiting
+// for its fix. It never reaches the street's pins or counts. Pure; a row with no
+// name or no act is dropped (a desk row exists to be acted on).
+function normalizeDeskRow(raw, { desk, building }) {
+  if (!raw || typeof raw !== 'object' || raw.id == null || !raw.name) return null;
+  const acts = normalizeActs(raw.acts);
+  if (!acts.length) return null;
+  return {
+    id: `${desk}:${raw.id}`,
+    desk,
+    building,
+    name: String(raw.name).slice(0, 80),
+    fact: raw.fact == null ? '' : String(raw.fact).slice(0, 80),
+    facts: (Array.isArray(raw.facts) ? raw.facts : []).filter((x) => x != null && String(x).trim()).slice(0, 3).map((x) => String(x).slice(0, 80)),
+    needs: raw.needs === true,
+    // a row that is only a way to add something (allow another goal) is not a
+    // thing on the floor, so the floor does not count it
+    tool: raw.tool === true,
+    // a same-site page an 'open' act goes to; and the matter source this row
+    // stands in for on its floor (the core update's two-step replaces its link)
+    href: typeof raw.href === 'string' && raw.href.charAt(0) === '/' && raw.href.charAt(1) !== '/' ? raw.href : null,
+    over: typeof raw.over === 'string' && /^[a-z_]+$/.test(raw.over) ? raw.over : null,
+    opened_at: iso(raw.opened_at),
+    ref: raw.ref && typeof raw.ref === 'object' ? { type: String(raw.ref.type), id: String(raw.ref.id) } : null,
+    acts,
+    ...deskExtras(raw),
+  };
+}
+// Two optional shapes a desk row may carry (task 1004560): `pips`, promises kept
+// of total drawn as squares (at most 12), and `set`, the ordered set the row sits
+// in (a version id) so the desk can reorder its rows and save the order whole.
+function deskExtras(raw) {
+  const out = {};
+  const p = raw.pips;
+  if (p && Number.isInteger(p.of) && p.of > 0 && p.of <= 12 && Number.isInteger(p.on) && p.on >= 0 && p.on <= p.of) out.pips = { on: p.on, of: p.of };
+  if (typeof raw.set === 'string' && /^[A-Za-z0-9._-]{1,64}$/.test(raw.set)) out.set = raw.set;
+  return out;
+}
+
 // 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.
@@ -397,14 +486,16 @@ function registeredContributions() {
   const readings = new Map();
   const floors = new Map();
   const histories = new Map();
+  const desks = 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);
+    else if (typeof c.desk === 'string' && vocab.DESKS.some((d) => d.key === c.desk)) desks.set(c.desk, c);
   }
-  return { sources, readings, floors, histories };
+  return { sources, readings, floors, histories, desks };
 }
 
 // ── the collector ────────────────────────────────────────────────────────────
@@ -554,7 +645,25 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
       historySources.push({ source: key, building: c.building, status: 'unavailable' });
     }
   }));
-  const [floors] = await Promise.all([floorsP, historyP]);
+  // The desks (task 1004559): rows a viewer may act on in place, each read by its
+  // owning module under the atom its own write route checks. A gated-out desk is
+  // not_yours with no rows, so the floor shows its quiet line.
+  const deskImpls = new Map(contributions.desks || []);
+  const desksP = Promise.all(vocab.DESKS.map(async (decl) => {
+    const base = { key: decl.key, building: decl.building, status: null, rows: [] };
+    const impl = deskImpls.get(decl.key);
+    if (!impl) return { ...base, status: 'off' };
+    if (!gateAllows(impl.gate, ctx)) return { ...base, status: 'not_yours' };
+    try {
+      const raw = await withTimeout(Promise.resolve(impl.read(ctx, { now, once })), timeoutMs);
+      const rows = (Array.isArray(raw) ? raw : []).slice(0, MAX_DESK_ROWS).map((r) => normalizeDeskRow(r, { desk: decl.key, building: decl.building })).filter(Boolean);
+      return { ...base, status: 'live', rows };
+    } catch (err) {
+      log.warn({ desk: decl.key, err: err && err.message }, 'governor docket desk failed');
+      return { ...base, status: 'unavailable' };
+    }
+  }));
+  const [floors, , desks] = await Promise.all([floorsP, historyP, desksP]);
   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));
 
@@ -590,6 +699,7 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
     floors,
     history,
     history_sources: historySources,
+    desks,
     vocabulary: {
       buildings: vocab.BUILDINGS, rules: vocab.RULES, states: vocab.STATES,
       // The table's rule set — the matter glyphs plus vacant (no one holds it).
@@ -665,6 +775,8 @@ module.exports = {
   SOURCE_TIMEOUT_MS,
   normalizeFloor,
   normalizeHistory,
+  normalizeActs,
+  normalizeDeskRow,
   loadGovernment,
   SETTLED_WINDOW_MS,
   normalizeMatter,

package/modules/government/routes/government.js

@@ -110,6 +110,7 @@ const governmentPort = {
   // is no counterpart that records an outcome, and there must never be one: an
   // outcome is written by a close, never by the module reading it.
   boardPassForIdea: board.boardPassForIdea,
+  boardPassedIdeaIds: board.boardPassedIdeaIds,
   // task 1004429 (BV2.PS04): a finished genesis stage is put to the board — the
   // genesis home (task 1004423) calls this when a stage's tasks are done. The
   // finished-tasks gate lives inside board.js; the item is an ordinary one under
@@ -182,7 +183,20 @@ const { validateOrRespond, LIMITS, parseId } = api;
 const RANK_KEY_RE = /^[a-z][a-z0-9-]*$/;
 const RANK_KEY_MAX = 64;
 
+// The People desk's rank rows, under the assignments routes' own atom (task 1004559).
+function contributeRankDesk() {
+  api.contribute('governor.docket', {
+    desk: 'people.ranks',
+    gate: { permission: 'government.manage' },
+    read: async () => {
+      const [ranks, assignments] = await Promise.all([db.listRanksWithGrants(), db.listAssignments()]);
+      return require('../docket-floors').rankDeskRows(ranks, assignments);
+    },
+  });
+}
+
 module.exports = function buildGovernmentRouter() {
+  contributeRankDesk();
   registerSeams();
   const router = express.Router();
 
@@ -776,7 +790,7 @@ module.exports = function buildGovernmentRouter() {
         proposedBy: req.builder.id,
       });
       if (!out.ok) {
-        if (out.reason === 'decided_by_gate' || out.reason === 'no_one_holds_this') {
+        if (out.reason === 'decided_by_gate' || out.reason === 'no_one_holds_this' || out.reason === 'action_not_wired') {
           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, {