@bongos/core 1.21.35 → 1.21.36

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-vocab.js

@@ -101,6 +101,11 @@ const DESKS = Object.freeze([
   ['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 = {

package/modules/government/docket.js

@@ -250,8 +250,19 @@ function normalizeDeskRow(raw, { desk, building }) {
     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

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
@@ -789,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, {

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

@@ -512,6 +512,60 @@
   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;
+  // The Planning desks (task 1004560). A blocker is decided by one of its chips,
+  // whose words are the resolution note; a criterion proposal ratifies in one
+  // tap; a Full Idea the board carried becomes a goal in the version its chip names.
+  ACT_ROUTES.blockers = {
+    decide: function (id, inp) { return str(inp.option).trim() ? post('/blockers/' + id + '/resolve', { resolution_note: 'Decided on the floor desk: ' + str(inp.option).trim() + '.' }) : null; },
+  };
+  // task 1004561: a builder's monthly limit (PATCH /builders/:id/budget; the
+  // 'none' chip clears it), and a sign-off undone (POST /done-when/:id/unsatisfy,
+  // the chip's words as the reason it logs).
+  ACT_ROUTES.builder_budget = {
+    budget: function (id, inp) { return inp.option ? call('PATCH', '/builders/' + id + '/budget', { monthly_budget_usd: inp.option === 'none' ? null : Number(inp.option) }) : null; },
+  };
+  ACT_ROUTES.signed_criterion = { unsign: function (id, inp) { return post('/done-when/' + id + '/unsatisfy', { reason: str(inp.label) || 'undone on the floor desk' }); } };
+  // The same acts at a building a sitting decides (task 1004561): filed as the
+  // building's matter, which carries the act out once it passes. Each returns
+  // { title, action } for POST /government/board/matters.
+  var COUNCIL_ACTS = {
+    autobongos_fence: {
+      switch_on: function () { return { title: 'Switch unattended building on', action: { type: 'switch_on' } }; },
+      switch_off: function () { return { title: 'Switch unattended building off', action: { type: 'switch_off' } }; },
+      allow: function (id, inp) { return inp.option ? { title: 'Allow ' + str(inp.label || 'goal ' + inp.option) + ' to build unattended', action: { type: 'allow_goal', goal_id: Number(inp.option) } } : null; },
+    },
+    criteria_uat: { force: function (id, inp, who) { return { title: 'Sign off: ' + who, action: { type: 'satisfy_criterion', criterion_id: Number(id) } }; } },
+    override_requests: { release: function (id, inp, who) { return { title: 'Release past its check: ' + who, action: { type: 'approve_override', request_id: Number(id) } }; } },
+    gate_approvals: { release: function (id, inp, who) { return { title: 'Release from the gate: ' + who, action: { type: 'approve_gate', pr: Number(id) } }; } },
+    builder_budget: {
+      budget: function (id, inp, who) { return inp.option ? { title: who + ': ' + str(inp.label || inp.option), action: { type: 'set_budget', builder_id: Number(id), monthly_usd: inp.option === 'none' ? null : Number(inp.option) } } : null; },
+    },
+  };
+  COUNCIL_ACTS.autonomy_fence = COUNCIL_ACTS.autobongos_fence;
+  COUNCIL_ACTS.autonomy_goal = { allow: COUNCIL_ACTS.autobongos_fence.allow };
+  function councilRequest(s, key, inp) {
+    var make = COUNCIL_ACTS[s.kind] && COUNCIL_ACTS[s.kind][key];
+    var m = make ? make(decoded(s.id), inp, str(s.who) || 'a matter') : null;
+    return m ? post('/government/board/matters', { area: s.council, title: str(m.title).slice(0, 200), action: m.action }) : null;
+  }
+  ACT_ROUTES.criterion_proposal = { ratify: function (id) { return post('/inbox/' + id + '/ratify', { notes_md: 'Ratified on the floor desk.' }); } };
+  ACT_ROUTES.full_idea = {
+    ratify_goal: function (id, inp) { return inp.option ? post('/inbox/' + id + '/ratify-goal', { target_version: str(inp.option), notes_md: 'Ratified on the floor desk.' }) : null; },
+  };
+  // The Priorities desk's save (task 1004560): the new order goes to
+  // POST /goals/reorder, or, where the decision table puts Planning to a sitting,
+  // it is filed as a Planning matter for the sitting to decide. save is the desk
+  // model's { set, ids, names, council }.
+  function orderRequest(save) {
+    var s = save || {};
+    var ids = (s.ids || []).map(Number).filter(function (n) { return n > 0 && Math.floor(n) === n; });
+    if (!ids.length) return null;
+    if (s.council) {
+      var lines = (s.names || []).map(function (n, i) { return (i + 1) + '. ' + str(n); });
+      return post('/government/board/matters', { area: 'planning', title: 'A new order for the goals', detail_md: 'Proposed on the floor desk, for version ' + str(s.set) + ':\n\n' + lines.join('\n') });
+    }
+    return post('/goals/reorder', { version_id: str(s.set), ordered_ids: ids });
+  }
   function decoded(encoded) { return decodeURIComponent(encoded); }
   // input: { reason, section } for object; { text } for revise.
   function request(cv, key, input) {
@@ -541,6 +595,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 (s.council && COUNCIL_ACTS[s.kind] && COUNCIL_ACTS[s.kind][key]) return councilRequest(s, key, inp);
     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', {});
@@ -565,6 +620,9 @@
     var r = res || {};
     var who = cv && cv.subject && cv.subject.who ? cv.subject.who : 'They';
     var b = cv ? cv.building : null;
+    if (cv && cv.subject && cv.subject.council && COUNCIL_ACTS[cv.subject.kind] && COUNCIL_ACTS[cv.subject.kind][key]) {
+      return { toast: 'Sent to the council. It is carried out when they pass it.', building: b, kind: 'light', close: false };
+    }
     if (key === 'for') {
       if (r.item_closed && r.outcome === 'passed') return { toast: 'Passed. It is in force from today.', building: b, kind: 'rise', close: false };
       if (r.item_closed) return { toast: 'The sitting closed: it went back to its author.', building: b, kind: 'settle', close: false };
@@ -594,8 +652,10 @@
     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.',
+    decide: 'Decided. The work it held moves again.', ratify: 'Ratified. The promise is on its version.', ratify_goal: 'Ratified. It is a goal now.',
+    budget: '{who} has a new monthly limit.', unsign: 'Undone. The promise is open again.',
   };
-  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' };
+  var ACT_KINDS = { budget: 'light', unsign: 'settle', decide: 'rise', ratify: 'rise', ratify_goal: 'rise', 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 = {
@@ -786,7 +846,7 @@
 
   var api = {
     API: API, SECTIONS: SECTIONS, needsRoom: needsRoom, itemIdOf: itemIdOf, subjectKind: subjectKind,
-    model: model, actsCard: actsCard, request: request, check: check, answer: answer, refusal: refusal, render: render,
+    model: model, actsCard: actsCard, request: request, orderRequest: orderRequest, 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,

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

@@ -38,10 +38,20 @@
 //   GovDesk.fit(s, n, words)                 the line formatter
 //   GovDesk.breaks(desk)                     [] when the desk keeps the line rule
 //   GovDesk.todayPips(n)                     the street header's meter
+//   GovDesk.moved(order, key, by)            a desk order with one row moved
 //   GovDesk.LIMITS, ACT_WORDS, CHIPS, NOUNS, CLEAR
 // A desk row is { key, matter, ini, name, fact, facts[], actions[{ key, label,
 // tone, go, ask }], chips { for, ask, options[{ key, label, input }] } | null,
 // wait, needs, card }: `card` is the GovMatterCard model the act is sent with.
+//
+// THE PLANNING DESKS (task 1004560). A row may carry `pips` [{ key, on }]: a
+// goal's promises kept of total, or a vote's seats (filled = a yes). A row of an
+// ordered set (the Priorities desk: `order` is its version) is moved with its
+// two arrows; input.order is the order the viewer has made, and a changed order
+// gives the desk a `save` { line, label, set, ids, names, council }: the
+// council when the decision table puts Planning to a sitting that cannot act
+// alone, so the save files a Planning matter instead of setting the order. A
+// blocker's chips stand open (`show`): deciding it IS picking one.
 
 (function (root) {
   'use strict';
@@ -54,7 +64,7 @@
     nameWords: 3, name: 20, fact: 26, facts: 3, factLen: 24, actions: 2,
     tiles: 3, tileValue: 8, tileWords: 2, tileLabel: 14,
     status: 44, clearLine: 30, clearSub: 40, record: 4, recordLen: 30,
-    chips: 5, chip: 16, todayTarget: 10,
+    chips: 5, chip: 16, todayTarget: 10, pips: 12, saveLine: 48,
   });
 
   // One line, never more: the house rule for every row, tile and status. A cap
@@ -105,15 +115,29 @@
     switch_on: 'switch on', switch_off: 'switch off', allow: 'allow', disallow: 'disallow', first: 'first',
     pause: 'pause', resume: 'resume', tier: 'tier', deactivate: 'deactivate', give: 'give', take: 'take back',
     check: 'check', take_core: 'take it', rot: 'set', module_on: 'turn on', module_off: 'turn off', backup: 'back up', invite: 'invite', open: 'open',
+    // the Planning desks (task 1004560)
+    decide: 'decide', ratify: 'ratify', ratify_goal: 'make goal', up: 'move up', down: 'move down',
+    // task 1004561: a builder's monthly limit, and a sign-off undone
+    budget: 'set limit', unsign: 'undo',
   });
   // What a row's chips ask, per act (a reason or an option is one tap, never text).
-  const ASKS = Object.freeze({ check: 'check', take_core: 'move to', rot: 'stale after', module_off: 'sure', invite: 'their GitHub name', object: 'why', force: 'why', switch_off: 'why', pause: 'why', deactivate: 'why', signoff: 'confirm', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom' });
+  const ASKS = Object.freeze({ budget: 'monthly limit', unsign: 'why', decide: 'pick one', ratify_goal: 'which version', check: 'check', take_core: 'move to', rot: 'stale after', module_off: 'sure', invite: 'their GitHub name', object: 'why', force: 'why', switch_off: 'why', pause: 'why', deactivate: 'why', signoff: 'confirm', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom' });
   // How a floor counts rows nobody is waiting on (desk rows), by its desk.
   const DESK_NOUNS = Object.freeze({
     'people.builders': 'builders', 'people.ranks': 'ranks', 'disputes.confirmed': 'to fix',
     'automation.switch': 'switch', 'automation.goals': 'allowed', 'automation.runners': 'runners',
     'people.invite': 'invites', 'release.core': 'update', 'rules.settings': 'settings', 'rules.modules': 'modules', 'treasury.backup': 'backups',
+    'planning.order': 'goals in order', 'planning.ratify': 'to ratify',
+    'treasury.budgets': 'builders', 'review.signed': 'signed off',
   });
+  // Is this building decided by a sitting that cannot act alone (task 1004561)?
+  // The decision table's row, as the docket's buildings carry it: then a desk act
+  // is filed as the building's matter, and carried out once the sitting passes it.
+  function councilOf(docket, key) {
+    const b = docket && Array.isArray(docket.buildings) ? docket.buildings.find((x) => x && x.key === key) : null;
+    const d = b && b.decision ? b.decision : null;
+    return !!(d && d.sitting && ['decide', 'first'].indexOf(d.rule) < 0);
+  }
   // An objection's reason as one tap: the five sections the server accepts
   // (street-card.js SECTIONS), each in at most 16 characters.
   const CHIPS = Object.freeze({ scope: 'what it changes', purpose: 'its purpose', why_matters: 'why it matters', fit: 'how it fits', success: 'how to measure' });
@@ -185,6 +209,8 @@
       });
     }
     const cv = C && C.model ? C.model({ docket: ctx.docket, key: m.id, room: ctx.room, constitution: ctx.constitution, now: now, viewerId: ctx.viewerId }) : null;
+    // a release held for a sitting goes to it as a matter (task 1004561)
+    if (cv && cv.subject && cv.subject.itemId == null) cv.subject.council = councilOf(ctx.docket, cv.building) ? cv.building : null;
     const actions = [];
     let chips = null;
     if (cv && !cv.readOnly && !cv.loading) {
@@ -200,6 +226,8 @@
     return {
       key: str(m.id), matter: str(m.id), ini: initials(name), name: name, fact: fact, facts: facts,
       actions: actions, chips: chips, choices: chips ? { [chips.for]: chips } : {}, wait: wait, needs: stateOf(m) === 'needs', source: m.source, opened: m.opened_at || null, card: cv,
+      // a vote shows its seats: one pip each, filled for a yes
+      pips: cv && Array.isArray(cv.seats) && cv.seats.length ? cv.seats.slice(0, LIMITS.pips).map((s, i) => ({ key: 's' + i, on: s.pos === 'for' })) : null,
     };
   }
 
@@ -210,6 +238,8 @@
   // goes to the matter's own page (a sign-off that needs a recording).
   function actedRow(acts, card, ctx) {
     const titles = new Map((ctx.goals || []).map((g) => [str(g.id), str(g.title || 'goal ' + g.id)]));
+    // an act at a building a sitting decides is filed as its matter (task 1004561)
+    if (card && card.subject) card.subject.council = councilOf(ctx.docket, card.building) ? card.building : null;
     const actions = [];
     const choices = {};
     acts.forEach((a) => {
@@ -232,7 +262,9 @@
       actions.push({ key: a.key, label: ACT_WORDS[word], tone: actions.length ? 'quiet' : 'primary', go: goes ? card.href : null, ask: ask });
     });
     const first = actions.find((a) => a.ask);
-    return { actions: actions, chips: first ? choices[first.key] : null, choices: choices, wait: actions.length ? '' : 'not from here', card: card };
+    // deciding a blocker is picking one of its options: its chips stand open
+    const show = first && first.key === 'decide' && choices.decide ? 'decide' : null;
+    return { actions: actions, chips: first ? choices[first.key] : null, choices: choices, show: show, wait: actions.length ? '' : 'not from here', card: card };
   }
 
   // A desk row (task 1004559): something on this floor the viewer may act on that
@@ -253,6 +285,8 @@
     return Object.assign(actedRow(d.acts || [], card || { href: null }, ctx), {
       key: str(d.id), matter: str(d.id), ini: initials(name), name: name, fact: fit(d.fact, LIMITS.fact), facts: facts,
       needs: d.needs === true, source: d.desk, opened: d.opened_at || null, desk: true, tool: d.tool === true, over: d.over || null,
+      order: d.set || null, goalId: d.set && ref.id != null ? str(ref.id) : null, full: full,
+      pips: d.pips ? Array.from({ length: Math.min(d.pips.of, LIMITS.pips) }, (_, i) => ({ key: 'p' + i, on: i < d.pips.on })) : null,
     });
   }
   // The desk rows of one floor: those of the desk its PLAN entry names.
@@ -292,13 +326,27 @@
     const spec = plan.floors[floor];
     const fl = I.floorFor(spec, { key: o.key, docket: docket, goals: o.goals || [], now: o.now || 0 });
     const ctx = { room: o.room, constitution: o.constitution, now: o.now || 0, viewerId: o.viewerId, done: o.done, goals: o.goals || [] };
-    const rows = docket ? rowsFor(o.key, floor, docket, ctx) : [];
+    let rows = docket ? rowsFor(o.key, floor, docket, ctx) : [];
+    // the Priorities desk: the ordered rows in the order the viewer has made
+    const ordered = rows.filter((r) => r.order);
+    let save = null;
+    if (ordered.length > 1) {
+      const base = ordered.map((r) => r.key);
+      const want = Array.isArray(o.order) ? o.order.map(str) : null;
+      const mine = want && want.length === base.length && base.every((k) => want.indexOf(k) >= 0) ? want : base;
+      const sorted = mine.map((k) => ordered.find((r) => r.key === k));
+      sorted.forEach((r, i) => { r.pos = i + 1; r.top = i === 0; r.bottom = i === sorted.length - 1; });
+      rows = rows.filter((r) => !r.order).concat(sorted);
+      if (mine.join('|') !== base.join('|')) save = saveOf(docket, o.key, sorted);
+    }
     const bind = spec[2] || {};
     const src = bind.source ? bind.source : bind.floor === 'planning.ideas' ? 'idea' : floor === 0 ? 'board' : null;
     const needs = rows.filter((r) => r.needs);
     const noun = NOUNS[src] || 'open';
     // rows nobody waits on: 'moving' for matters, the desk's own noun for desk rows
-    const moving = rows.length && rows.every((r) => r.desk) ? (DESK_NOUNS[rows[0].source] || 'here') : 'moving';
+    // (rows waiting on no one, when all of them are desk rows, count in their desk's noun: 'to ratify')
+    const rest = rows.filter((r) => !r.needs && !r.tool);
+    const moving = rest.length && rest.every((r) => r.desk) ? (DESK_NOUNS[rest[0].source] || 'here') : 'moving';
     const counted = rows.filter((r) => !r.tool);
     const oldestOf = (list) => list.reduce((a, r) => (r.opened && (!a || Date.parse(r.opened) < Date.parse(a)) ? r.opened : a), null);
     const cleared = !!o.cleared && rows.length === 0;
@@ -320,7 +368,13 @@
       const words = str(l).replace(/\s+/g, ' ').trim().split(' ').slice(0, LIMITS.tileWords).join(' ').replace(/[,.;:·-]+$/, '');
       tiles.push({ key: 't' + tiles.length, v: fit(val, LIMITS.tileValue), l: fit(words, LIMITS.tileLabel) });
     };
-    if (rows.length) { tile(needs.length, noun); tile(counted.length - needs.length, moving); }
+    if (ordered.length > 1) {
+      // the order's one number: the share of its goals' promises kept
+      const on = ordered.reduce((a, r) => a + (r.pips || []).filter((p) => p.on).length, 0);
+      const of = ordered.reduce((a, r) => a + (r.pips || []).length, 0);
+      tile(needs.length, noun);
+      if (of) tile(Math.round((100 * on) / of) + '%', 'promises kept');
+    } else if (rows.length) { tile(needs.length, noun); tile(counted.length - needs.length, moving); }
     else if (fl.count) tile(fl.count, str(fl.line).replace(/^[$]?[0-9][0-9,.%]*\s*/, '') || 'on this floor');
     tile(history.length, 'on record');
     const record = (o.mine || []).map((t, i) => ({ key: 'm' + i, text: fit(t + ' · now', LIMITS.recordLen), mine: true }))
@@ -330,13 +384,50 @@
       key: o.key + ':' + floor, building: o.key, floor: floor, name: spec[0], sym: o.sym || { d: '', f: '' },
       status: fit(status, LIMITS.status), hot: hot,
       tiles: tiles.slice(0, LIMITS.tiles), rows: rows,
-      quiet: quiet, cleared: cleared,
+      quiet: quiet, cleared: cleared, save: save,
       clearLine: fit(cleared ? (CLEAR[src] || 'Floor clear') : 'Nothing needs you here', LIMITS.clearLine),
       clearSub: fit(cleared ? 'lit up · ' + (o.today || 0) + ' decided today' : fl.line, LIMITS.clearSub),
       record: record,
     };
   }
 
+  // ---------- the Priorities desk's save ----------
+  // Who decides the order: the decision table's Planning row, as the docket's
+  // buildings carry it. A sitting whose rule cannot act alone means the save
+  // files a matter for it; the yes it needs is read from its seats.
+  function yesNeeded(rule, n) {
+    if (!(n > 0)) return null;
+    if (rule === 'majority') return Math.floor(n / 2) + 1;
+    if (rule === 'unanimous') return n;
+    if (rule === 'signoff') return 1;
+    return null;
+  }
+  function saveOf(docket, key, sorted) {
+    const b = docket && Array.isArray(docket.buildings) ? docket.buildings.find((x) => x && x.key === key) : null;
+    const d = b && b.decision ? b.decision : null;
+    const council = councilOf(docket, key);
+    const yes = council ? yesNeeded(d.rule, Number(b.holder_count)) : null;
+    const line = !council ? 'new order · saved for everyone'
+      : d.rule === 'consent' ? 'new order · to the council · unless one objects'
+      : 'new order · goes to the council' + (yes ? ' · ' + yes + ' yes needed' : '');
+    // what the toast says once it is sent: whole sentences, never the line cut up
+    const said = !council ? 'Saved. Goals are worked in this order now.'
+      : d.rule === 'consent' ? 'The new order is with the council. It passes unless someone objects.'
+      : 'The new order is with the council.' + (yes ? ' It needs ' + yes + ' yes.' : '');
+    return {
+      line: fit(line, LIMITS.saveLine), label: council ? 'send to council' : 'save order', council: council, said: said,
+      set: sorted[0].order, ids: sorted.map((r) => r.goalId), names: sorted.map((r) => r.full || r.name),
+    };
+  }
+  // An order with one row moved one place (by -1 up, +1 down); the ends hold.
+  function moved(order, key, by) {
+    const o = (order || []).slice();
+    const i = o.indexOf(key), j = i + by;
+    if (i < 0 || j < 0 || j >= o.length) return o;
+    o[i] = o[j]; o[j] = key;
+    return o;
+  }
+
   // ---------- the rule as a checker ----------
   function breaks(desk) {
     const out = [];
@@ -364,7 +455,9 @@
         if ((!c.field && !c.options.length) || c.options.length > LIMITS.chips || c.options.some((x) => !x.label || x.label.length > LIMITS.chip)) bad('chips', c.options.map((x) => x.label));
       });
       if (r.actions.some((a) => a.ask && !(r.choices || {})[a.key])) bad('an ask without its own chips', r.name);
+      if (r.pips && r.pips.length > LIMITS.pips) bad('more than twelve pips', r.pips.length);
     });
+    if (desk.save && (!oneLine(desk.save.line) || desk.save.line.length > LIMITS.saveLine)) bad('save line', desk.save.line);
     if (desk.record.length > LIMITS.record || desk.record.some((x) => !oneLine(x.text) || x.text.length > LIMITS.recordLen)) bad('record line', desk.record.map((x) => x.text));
     return out;
   }
@@ -379,7 +472,7 @@
 
   const api = {
     LIMITS: LIMITS, ACT_WORDS: ACT_WORDS, ASKS: ASKS, DESK_NOUNS: DESK_NOUNS, CHIPS: CHIPS, NOUNS: NOUNS, CLEAR: CLEAR,
-    fit: fit, ageWord: ageWord, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips,
+    fit: fit, ageWord: ageWord, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips, moved: moved,
   };
   root.GovDesk = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;