@bongos/core 1.21.34 → 1.21.35

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/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,19 @@ 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'],
+].map(([key, building]) => Object.freeze({ key, building })));
+
 module.exports = {
   BUILDINGS,
   BUILDING_KEYS,
@@ -99,4 +112,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,6 +182,74 @@ 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,
   };
 }
 
@@ -397,14 +475,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 +634,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 +688,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 +764,8 @@ module.exports = {
   SOURCE_TIMEOUT_MS,
   normalizeFloor,
   normalizeHistory,
+  normalizeActs,
+  normalizeDeskRow,
   loadGovernment,
   SETTLED_WINDOW_MS,
   normalizeMatter,

package/modules/government/routes/government.js

@@ -182,7 +182,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();
 

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

@@ -440,8 +440,79 @@
     return sourceCard(cv, m);
   }
 
+  // ---------- the acts the server hands a row (task 1004559) ----------
+  // A docket matter or desk row may carry `acts`: what THIS viewer may do, which
+  // the owning module decided from the same atom its route checks. The floor
+  // desk sends them through this card: { kind, id, who } is all a route needs.
+  // kind is the matter's source, or the desk row's ref type.
+  function actsCard(o) {
+    var x = o || {};
+    return {
+      key: str(x.key), building: x.building || null, where: '', when: '', title: str(x.title), href: safeHref(x.href),
+      source: str(x.kind), quote: null, change: null, revision: null, seats: [], tally: '', voices: [], counsel: null,
+      result: '', actions: [], textActions: [], objectForm: null, reviseForm: null, readOnly: false, loading: false, lines: [],
+      subject: { kind: str(x.kind), id: str(x.id), who: str(x.who) },
+    };
+  }
+
   // ---------- act → route ----------
   function post(url, body) { return { method: 'POST', url: API + url, body: body || {} }; }
+  function call(method, url, body) { return { method: method, url: API + url, body: body || {} }; }
+  // The routes behind the server-handed acts. inp.option is the chip's key, and
+  // inp.label its words (sent as the reason where a route keeps one).
+  var ACT_ROUTES = {
+    redteam_reports: {
+      confirm: function (id) { return post('/security/reports/' + id + '/confirm', {}); },
+      dispute: function (id) { return post('/security/reports/' + id + '/dispute', {}); },
+    },
+    vulnerability_report: { fix: function (id) { return post('/security/reports/' + id + '/fix', {}); } },
+    removal_proposals: {
+      remove: function (id) { return post('/removal-proposals/' + id + '/decide', { verdict: 'confirmed' }); },
+      keep: function (id) { return post('/removal-proposals/' + id + '/decide', { verdict: 'dismissed' }); },
+    },
+    criteria_uat: {
+      signoff: function (id) { return post('/done-when/' + id + '/uat', { kind: 'backend_signoff', live_attested: true }); },
+      force: function (id, inp) { return post('/done-when/' + id + '/satisfy', { override_reason: 'Signed off on the floor desk: ' + str(inp.label || 'forced') + '.' }); },
+    },
+    autobongos_fence: {
+      switch_on: function () { return post('/autonomy/fence', { enabled: true }); },
+      switch_off: function (id, inp) { return post('/autonomy/fence', { enabled: false, reason: str(inp.label) || 'switched off on the floor desk' }); },
+      allow: function (id, inp) { return inp.option ? post('/autonomy/fence/goals', { goal_id: Number(inp.option) }) : null; },
+    },
+    autonomy_goal: {
+      first: function (id) { return post('/autonomy/fence/priority', { goal_id: Number(id) }); },
+      disallow: function (id) { return call('DELETE', '/autonomy/fence/goals/' + id); },
+      allow: function (id, inp) { return inp.option ? post('/autonomy/fence/goals', { goal_id: Number(inp.option) }) : null; },
+    },
+    autonomy_runner: {
+      pause: function (id, inp) { return post('/autonomy/builders/' + id + '/pause', { paused: true, reason: str(inp.label) || 'paused on the floor desk' }); },
+      resume: function (id) { return post('/autonomy/builders/' + id + '/pause', { paused: false }); },
+    },
+    builder: {
+      tier: function (id, inp) { return inp.option ? call('PATCH', '/builders/' + id + '/rank', { rank: str(inp.option) }) : null; },
+      deactivate: function (id, inp) { return call('PATCH', '/builders/' + id + '/status', { status: 'inactive', reason: str(inp.label) || 'deactivated on the floor desk' }); },
+    },
+    custom_rank: {
+      give: function (id, inp) { return inp.option ? post('/government/assignments', { builder_id: Number(inp.option), rank_key: decoded(id) }) : null; },
+      take: function (id, inp) { return inp.option ? call('DELETE', '/government/assignments/' + encodeURIComponent(str(inp.option)) + '/' + id) : null; },
+    },
+  };
+  // The core update's two steps (POST /provisioning/instances/:id/core-upgrade):
+  // the server hands 'take' only once a dry run passed for that very version, and
+  // the chip carries the version, so no card moves the pin without that check.
+  ACT_ROUTES.core_pin = {
+    check: function (id, inp) { return inp.option ? post('/provisioning/instances/' + id + '/core-upgrade', { to: str(inp.option), dry_run: true }) : null; },
+    take: function (id, inp) { return inp.option ? post('/provisioning/instances/' + id + '/core-upgrade', { to: str(inp.option) }) : null; },
+  };
+  ACT_ROUTES.project_setting = { rot: function (id, inp) { return inp.option ? call('PATCH', '/project-settings/rot-days', { days: Number(inp.option) }) : null; } };
+  ACT_ROUTES.module = {
+    module_on: function (id) { return post('/modules/' + id + '/enable', { enabled: true }); },
+    module_off: function (id) { return post('/modules/' + id + '/enable', { enabled: false }); },
+  };
+  ACT_ROUTES.backup = { backup: function () { return post('/backup/trigger', {}); } };
+  ACT_ROUTES.invite = { invite: function (id, inp) { return str(inp.option).trim() ? post('/access-requests/invite', { github_login: str(inp.option).trim() }) : null; } };
+  ACT_ROUTES.autonomy_fence = ACT_ROUTES.autobongos_fence;
+  function decoded(encoded) { return decodeURIComponent(encoded); }
   // input: { reason, section } for object; { text } for revise.
   function request(cv, key, input) {
     if (!cv || !cv.subject) return null;
@@ -470,6 +541,7 @@
       if (key === 'fine') return post('/goals/' + enc(s.goalId) + '/requests/' + enc(s.id) + '/respond', { action: 'approve' });
       if (key === 'refuse') return post('/goals/' + enc(s.goalId) + '/requests/' + enc(s.id) + '/respond', { action: 'deny' });
     }
+    if (ACT_ROUTES[s.kind] && ACT_ROUTES[s.kind][key]) return ACT_ROUTES[s.kind][key](enc(s.id), inp);
     if (s.kind === 'override_requests' && key === 'release') return post('/override-requests/' + enc(s.id) + '/decide', { decision: 'approve' });
     if (s.kind === 'gate_approvals' && key === 'release') return post('/gate-approvals/' + enc(s.id) + '/approve', {});
     return null; // hold, abstain and the core's release (a link) record nothing here
@@ -505,9 +577,26 @@
     if (key === 'release') return { toast: cv && cv.source === 'gate_approvals' ? 'Released from the gate. It merges and goes live.' : 'Released. It goes live.', building: b, kind: 'rise', close: true };
     if (key === 'fine') return { toast: cv && cv.source === 'goal_join_requests' ? 'Noted. ' + who + ' joins the team.' : 'Noted. ' + who + ' is invited in.', building: b, kind: 'rise', close: false };
     if (key === 'refuse') return { toast: 'Noted. ' + who + ' is not let in.', building: b, kind: 'settle', close: false };
+    if (key === 'take' && cv && cv.subject && cv.subject.kind === 'core_pin') return { toast: ACT_TOASTS.take_core, building: b, kind: 'rise', close: false };
+    if (key === 'invite') return { toast: ACT_TOASTS.invite.replace('{who}', r.github_login || 'They'), building: b, kind: 'light', close: false };
+    if (ACT_TOASTS[key]) return { toast: ACT_TOASTS[key].replace('{who}', who), building: b, kind: ACT_KINDS[key] || 'light', close: false };
     return { toast: '', building: null, kind: null, close: false };
   }
 
+  // What the street says after a server-handed act (task 1004559).
+  var ACT_TOASTS = {
+    confirm: 'Confirmed. The report is on the record.', dispute: 'Disputed. The report is closed as not a flaw.', fix: 'Marked fixed.',
+    remove: 'Removal confirmed.', keep: 'Kept. The removal is dismissed.',
+    signoff: 'Signed off. The promise counts as kept.', force: 'Signed off by force. The reason is on the record.',
+    switch_on: 'Switched on. Unattended building can start.', switch_off: 'Switched off. Nothing new starts unattended.',
+    allow: 'Allowed. It may build that goal now.', disallow: 'No longer allowed.', first: 'First in line now.',
+    pause: '{who} is paused.', resume: '{who} may run again.',
+    tier: '{who} has a new tier.', deactivate: '{who} is deactivated.', give: 'Rank given.', take: 'Rank taken back.',
+    check: 'Checking it. The answer lands on this floor in a couple of minutes; nothing moves.', take_core: 'Taking it. The core moves on the runner\'s next tick.',
+    rot: 'Rot timer set.', module_on: 'Turned on.', module_off: 'Turned off.', backup: 'Backing up now.', invite: '{who} is invited.',
+  };
+  var ACT_KINDS = { check: 'light', rot: 'light', module_on: 'rise', module_off: 'settle', backup: 'light', confirm: 'settle', dispute: 'settle', fix: 'rise', remove: 'settle', keep: 'settle', signoff: 'rise', force: 'rise', switch_on: 'rise', switch_off: 'settle', allow: 'rise', disallow: 'settle', first: 'light', pause: 'settle', resume: 'rise', tier: 'light', deactivate: 'settle', give: 'light', take: 'settle' };
+
   // A refused act, in words. The server's own message wins when it has one.
   var REFUSALS = {
     not_board_member: 'Only the members of this sitting may vote on it.',
@@ -522,6 +611,13 @@
     proposer_would_lose_their_seat: 'Re-filing this would take your own seat. Change it in the Board Room.',
     no_change: 'That already is how it works.',
     preview_readonly: 'This preview records nothing.',
+    decided_by_sitting: 'The council decides this now. Put it to a sitting.',
+    cannot_change_own_status: 'Ask another archon to change your own standing.',
+    already_member: 'They already have an account here.',
+    bad_github_login: 'That does not look like a GitHub name.',
+    backup_already_running: 'A backup is already running.',
+    intent_conflict: 'Another core run is going. Try again when it settles.',
+    criterion_needs_recording: 'This one needs a recording. Sign it off on its goal page.',
   };
   function refusal(status, body) {
     var e = body && body.error ? body.error : {};
@@ -690,7 +786,7 @@
 
   var api = {
     API: API, SECTIONS: SECTIONS, needsRoom: needsRoom, itemIdOf: itemIdOf, subjectKind: subjectKind,
-    model: model, request: request, check: check, answer: answer, refusal: refusal, render: render,
+    model: model, actsCard: actsCard, 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,