@bongos/core 1.21.34 → 1.21.36

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

@@ -440,8 +440,133 @@
     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;
+  // 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) {
     if (!cv || !cv.subject) return null;
@@ -470,6 +595,8 @@
       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', {});
     return null; // hold, abstain and the core's release (a link) record nothing here
@@ -493,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 };
@@ -505,9 +635,28 @@
     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.',
+    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 = { 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 = {
     not_board_member: 'Only the members of this sitting may vote on it.',
@@ -522,6 +671,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 +846,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, 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
@@ -97,7 +107,37 @@
     gate_approvals: 'Everything ready is live', blockers: 'Nothing blocked on you', board: 'Every vote is in', idea: 'No ideas waiting',
   });
   // The card's acts under the desk's words (the board's button labels).
-  const ACT_WORDS = Object.freeze({ for: 'yes', object: 'no', fine: 'let in', refuse: 'not now', release: 'release', hold: 'hold' });
+  const ACT_WORDS = Object.freeze({
+    for: 'yes', object: 'no', fine: 'let in', refuse: 'not now', release: 'release', hold: 'hold',
+    // the acts the server hands a row (task 1004559), each its old page's route
+    confirm: 'confirm', dispute: 'dispute', fix: 'fixed', remove: 'remove', keep: 'keep',
+    signoff: 'sign off', record: 'record it', force: 'force',
+    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({ 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' });
@@ -161,7 +201,16 @@
     if (when) add('closes ' + when);
     if (m.where) add(str(m.where).toLowerCase());
     add(STATE[stateOf(m)]);
+    if (Array.isArray(m.acts) && m.acts.length && C && C.actsCard) {
+      const ac = C.actsCard({ key: m.id, kind: m.source, id: m.ref && m.ref.id != null ? m.ref.id : str(m.id).replace(/^[^:]*:/, ''), who: person || name, title: m.title, building: m.building, href: m.href });
+      return Object.assign(actedRow(m.acts, ac, ctx), {
+        key: str(m.id), matter: str(m.id), ini: initials(name), name: name, fact: fact, facts: facts,
+        needs: stateOf(m) === 'needs', source: m.source, opened: m.opened_at || null,
+      });
+    }
     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) {
@@ -176,13 +225,90 @@
     const wait = actions.length ? '' : cv && cv.loading ? 'reading…' : stateOf(m) === 'needs' ? 'not from here' : 'moving';
     return {
       key: str(m.id), matter: str(m.id), ini: initials(name), name: name, fact: fact, facts: facts,
-      actions: actions, chips: chips, wait: wait, needs: stateOf(m) === 'needs', source: m.source, opened: m.opened_at || null, card: cv,
+      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,
     };
   }
+
+  // The buttons and chips of a row whose acts the server handed it (task
+  // 1004559). An act with options asks first, with its options as one-tap chips;
+  // `pick: 'open_goals'` offers the open goals the street already reads; an act
+  // whose chips come out empty is left off rather than drawn dead. 'record'
+  // 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) => {
+      // the core's 'take' is its own word ('take it'), not the rank's 'take back'
+      const word = a.key === 'take' && card.subject && card.subject.kind === 'core_pin' ? 'take_core' : a.key;
+      if (actions.length >= LIMITS.actions || !ACT_WORDS[word]) return;
+      let options = (a.options || []).map((o) => ({ key: str(o.key), label: fit(o.label, LIMITS.chip), input: { option: str(o.key), label: str(o.label) } }));
+      if (a.pick === 'open_goals') {
+        const except = new Set((a.except || []).map(str));
+        options = (ctx.goals || []).filter((g) => g && !except.has(str(g.id))).slice(0, LIMITS.chips)
+          .map((g) => ({ key: str(g.id), label: fit(titles.get(str(g.id)), LIMITS.chip), input: { option: str(g.id), label: titles.get(str(g.id)) } }));
+        if (!options.length) return;
+      }
+      options = options.slice(0, LIMITS.chips);
+      const goes = a.key === 'record' || a.key === 'open';
+      if (goes && !card.href) return;
+      const field = a.field || null;
+      const ask = options.length > 0 || !!field;
+      if (ask) choices[a.key] = field ? { for: a.key, ask: ASKS[word] || 'which', field: field, options: [] } : { for: a.key, ask: ASKS[word] || 'which', options: options };
+      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);
+    // 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
+  // no one is waiting on, read by the module that owns its route.
+  function deskRowOf(d, ctx) {
+    const titles = new Map((ctx.goals || []).map((g) => [str(g.id), str(g.title || '')]));
+    const hit = /^goal (\d+)$/.exec(str(d.name));
+    const full = hit && titles.get(hit[1]) ? titles.get(hit[1]) : str(d.name);
+    const name = fit(full, LIMITS.name, LIMITS.nameWords);
+    const age = ageWord(d.opened_at, ctx.now || 0);
+    const facts = [];
+    const add = (t) => { const v = fit(t, LIMITS.factLen); if (v && facts.indexOf(v) < 0 && facts.length < LIMITS.facts) facts.push(v); };
+    if (full !== name) add(full);
+    (d.facts || []).forEach(add);
+    if (age) add('since ' + age);
+    const ref = d.ref || {};
+    const card = C && C.actsCard ? C.actsCard({ key: d.id, kind: ref.type, id: ref.id, who: full, title: full, building: d.building, href: d.href }) : null;
+    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.
+  function deskRows(key, floor, docket, ctx) {
+    const plan = I && I.PLAN[key];
+    const spec = plan && plan.floors[floor];
+    const bind = (spec && spec[2]) || {};
+    if (!bind.desk || !docket || !Array.isArray(docket.desks)) return [];
+    // a floor may hold more than one desk (Rules in force: the settings and the modules)
+    const keys = [].concat(bind.desk);
+    return docket.desks.filter((x) => x && keys.indexOf(x.key) >= 0 && x.status === 'live' && Array.isArray(x.rows))
+      .reduce((all, x) => all.concat(x.rows.filter((r) => r && r.building === key)), []);
+  }
   function rowsFor(key, floor, docket, ctx) {
     const c = Object.assign({ docket: docket }, ctx || {});
     const done = c.done || {};
-    return floorMatters(key, floor, docket).filter((m) => !done[str(m.id)]).map((m) => rowOf(m, c))
+    const desked = deskRows(key, floor, docket).filter((d) => !done[str(d.id)]).map((d) => deskRowOf(d, c)).filter((r) => r.actions.length);
+    // a desk row that stands in for a source (the core update's check-then-take)
+    // replaces that source's matter rows on this floor
+    const over = desked.map((r) => r.over).filter(Boolean);
+    return floorMatters(key, floor, docket).filter((m) => !done[str(m.id)] && over.indexOf(m.source) < 0).map((m) => rowOf(m, c))
+      .concat(desked)
       .sort((a, b) => (b.needs - a.needs) || ((Date.parse(a.opened || 0) || 0) - (Date.parse(b.opened || 0) || 0)));
   }
 
@@ -199,19 +325,37 @@
     const floor = Math.max(0, Math.min(Number(o.floor) || 0, plan.floors.length - 1));
     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 };
-    const rows = docket ? rowsFor(o.key, floor, docket, ctx) : [];
+    const ctx = { room: o.room, constitution: o.constitution, now: o.now || 0, viewerId: o.viewerId, done: o.done, goals: o.goals || [] };
+    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
+    // (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;
     const quiet = rows.length === 0;
     let status, hot = false;
     if (!docket) status = 'the docket could not be read';
     else if (needs.length) { hot = true; const age = ageWord(oldestOf(needs), o.now); status = needs.length + ' ' + noun + (age ? ' · oldest ' + age : ''); }
-    else if (rows.length) { const age = ageWord(oldestOf(rows), o.now); status = rows.length + ' moving' + (age ? ' · oldest ' + age : ''); }
+    else if (counted.length) { const age = ageWord(oldestOf(counted), o.now); status = counted.length + ' ' + moving + (age ? ' · oldest ' + age : ''); }
+    else if (rows.length) status = fl.line;
     else if (cleared) status = 'floor clear';
     else status = 'nothing needs you · ' + fl.line;
     const history = docket && Array.isArray(docket.history) ? docket.history.filter((h) => h && h.building === o.key) : [];
@@ -224,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(rows.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 }))
@@ -234,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 = [];
@@ -263,7 +450,14 @@
       if (r.facts.length > LIMITS.facts || r.facts.some((f) => !oneLine(f) || f.length > LIMITS.factLen)) bad('row facts', r.facts);
       if (r.chips && (r.chips.options.length > LIMITS.chips || r.chips.options.some((c) => c.label.length > LIMITS.chip))) bad('chips', r.chips.options.map((c) => c.label));
       if (r.actions.some((a) => a.ask) && !r.chips) bad('a reason without chips', r.name);
+      Object.keys(r.choices || {}).forEach((k) => {
+        const c = r.choices[k];
+        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;
   }
@@ -277,8 +471,8 @@
   }
 
   const api = {
-    LIMITS: LIMITS, ACT_WORDS: ACT_WORDS, CHIPS: CHIPS, NOUNS: NOUNS, CLEAR: CLEAR,
-    fit: fit, ageWord: ageWord, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips,
+    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, moved: moved,
   };
   root.GovDesk = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;

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

@@ -112,6 +112,8 @@
   const PLAN_SYMBOLS = {
     'Rules in force': 'gavel', 'New rules': 'wrench', 'Security reports': 'shield', 'Removals': 'removal', 'Grade appeals': 'scales',
     'Goals': 'flag', 'Promises': 'seal', 'Spending matters': 'coins',
+    // the Desks board's name for the blockers floor (task 1004560)
+    'Waiting on you': 'hourglass',
   };
   function floorSymbol(name) {
     return PROTO_SYMBOLS[name] || PLAN_SYMBOLS[name] || 'crate';
@@ -331,42 +333,43 @@
     rules: {
       holds: 'Standing rules. Each one settles a kind of matter so the council never votes on it again.', rule: 'majority', cap: 8,
       growth: 'When the hall fills, the council can open an annex for one area, such as money rules.', annex: 'room for an annex, such as money rules',
-      floors: [['Rules in force', 'the rules settling matters now', { floor: 'rules.in_force', reading: 'rules' }], ['New rules', 'a rule put to the council', { source: 'standing_rules' }]],
+      floors: [['Rules in force', 'the rules settling matters now', { floor: 'rules.in_force', reading: 'rules', desk: ['rules.settings', 'rules.modules'] }], ['New rules', 'a rule put to the council', { source: 'standing_rules' }]],
     },
     disputes: {
       holds: 'Grade appeals, removal requests and security reports. Every ruling becomes precedent for the next one.', rule: 'decide', cap: 5,
       growth: 'Busy weeks go to a panel of three once a second room is built.', annex: 'room for a second room, a panel of three',
-      floors: [['Security reports', 'flaws found in our own walls', { source: 'redteam_reports' }], ['Removals', 'work proposed for removal', { source: 'removal_proposals' }], ['Grade appeals', 'a grade someone asks to change', { source: 'grade_appeals' }]],
+      floors: [['Security reports', 'flaws found in our own walls', { source: 'redteam_reports', desk: 'disputes.confirmed' }], ['Removals', 'work proposed for removal', { source: 'removal_proposals' }], ['Grade appeals', 'a grade someone asks to change', { source: 'grade_appeals' }]],
     },
     people: {
       holds: 'Who belongs, the rank each person holds, and who sits in which seat.', rule: 'consent', cap: 8,
       growth: 'A new floor opens whenever the charter creates a new seat.', annex: 'room for an annex of seats',
-      floors: [['The council', 'who sits, and for how long', { floor: 'people.council' }], ['Testers', 'who signs off finished work', { floor: 'people.testers' }], ['Builders', 'who builds here', { reading: 'people' }], ['Newcomers', 'builders on newcomer tasks', { floor: 'people.newcomers' }], ['Waiting to join', 'asked to join the project', { source: 'access_requests' }], ['Ranks', 'the ranks, and who holds each', { floor: 'people.ranks' }], ['Goal teams', 'asked to join a goal team', { source: 'goal_join_requests' }]],
+      floors: [['The council', 'who sits, and for how long', { floor: 'people.council' }], ['Testers', 'who signs off finished work', { floor: 'people.testers' }], ['Builders', 'who builds here', { reading: 'people', desk: 'people.builders' }], ['Newcomers', 'builders on newcomer tasks', { floor: 'people.newcomers' }], ['Waiting to join', 'asked to join the project', { source: 'access_requests', desk: 'people.invite' }], ['Ranks', 'the ranks, and who holds each', { floor: 'people.ranks', desk: 'people.ranks' }], ['Goal teams', 'asked to join a goal team', { source: 'goal_join_requests' }]],
     },
     planning: {
       holds: 'Goals, and the promises that say when each one is done. Kept promises are what the project owes its users.', rule: 'majority', cap: 9,
       growth: 'When it fills, the next new goal opens a second planning office.', annex: 'room for a second planning office',
-      floors: [['Goals', 'the open goals', { floor: 'planning.goals', goals: true }], ['Promises', 'what the goals say they deliver', { reading: 'promises' }], ['Ideas to ratify', 'full ideas waiting for a vote', { floor: 'planning.ideas' }], ['Priorities', 'the order goals are worked in', { floor: 'planning.priorities' }], ['Versions', 'what each version holds', { floor: 'planning.versions' }], ['Waiting on a decision', 'blockers holding work', { source: 'blockers' }]],
+      // the three desks first, as on the Desks board (task 1004560)
+      floors: [['Priorities', 'the order goals are worked in', { floor: 'planning.priorities', desk: 'planning.order' }], ['Ideas to ratify', 'ideas waiting to be ratified', { floor: 'planning.ideas', desk: 'planning.ratify' }], ['Waiting on you', 'blockers holding work', { source: 'blockers' }], ['Goals', 'the open goals', { floor: 'planning.goals', goals: true }], ['Promises', 'what the goals say they deliver', { reading: 'promises' }], ['Versions', 'what each version holds', { floor: 'planning.versions' }]],
     },
     automation: {
       holds: 'AI builders working on their own. You choose which goals they may build and how much they may spend, and you can stop them at any time.', rule: 'decide', cap: 6,
       growth: 'A new floor opens for each goal you let it build.', annex: 'room for an annex',
-      floors: [['The switch', 'unattended building, on or off', { source: 'autobongos_fence' }], ['Allowed goals', 'the goals it may build', { floor: 'automation.allowed_goals' }], ['Running now', 'builds in progress', { floor: 'automation.running' }], ['Spending limit', 'what it may spend', { floor: 'automation.spending_limit' }], ['Reports', 'what it did, told without asking', { floor: 'automation.reports' }]],
+      floors: [['The switch', 'unattended building, on or off', { source: 'autobongos_fence', desk: 'automation.switch' }], ['Allowed goals', 'the goals it may build', { floor: 'automation.allowed_goals', desk: 'automation.goals' }], ['Running now', 'builds in progress', { floor: 'automation.running', desk: 'automation.runners' }], ['Spending limit', 'what it may spend', { floor: 'automation.spending_limit' }], ['Reports', 'what it did, told without asking', { floor: 'automation.reports' }]],
     },
     review: {
       holds: 'Testing finished work and signing it off. Work does not count until someone who did not build it says it works.', rule: 'signoff', cap: 5,
       growth: 'When one queue of testers is not enough, an annex can take design reviews.', vacantGrowth: 'Nothing is built here until the charter says who holds the seat.', annex: 'room for an annex, such as design review',
-      floors: [['Testers', 'who signs off finished work', { floor: 'review.testers' }], ['Waiting outside', 'finished work waiting for a tester', { source: 'criteria_uat', held: 'Being tested' }], ['Signed off', 'work a tester has signed off', { floor: 'review.signed_off' }]],
+      floors: [['Testers', 'who signs off finished work', { floor: 'review.testers' }], ['Waiting outside', 'finished work waiting for a tester', { source: 'criteria_uat', held: 'Being tested' }], ['Signed off', 'work a tester has signed off', { floor: 'review.signed_off', desk: 'review.signed' }]],
     },
     release: {
       holds: 'Putting finished work live, and taking updates to Bongos itself.', rule: 'decide', cap: 7,
       growth: 'Room for a second gate if releases are ever split by area.', annex: 'room for a second gate',
-      floors: [['Overrides', 'past a failed check or grade', { source: 'override_requests' }], ['Modules', 'listed modules, and their re-checks', { source: 'module_rechecks' }], ['Held back', 'work held from going live', { floor: 'release.held_back' }], ['Core update', 'a new version of Bongos', { source: 'core_update' }], ['Live this month', 'what went live', { floor: 'release.live_month' }], ['Ready to go', 'signed off, waiting to go live', { source: 'gate_approvals' }]],
+      floors: [['Overrides', 'past a failed check or grade', { source: 'override_requests' }], ['Modules', 'listed modules, and their re-checks', { source: 'module_rechecks' }], ['Held back', 'work held from going live', { floor: 'release.held_back' }], ['Core update', 'a new version of Bongos', { source: 'core_update', desk: 'release.core' }], ['Live this month', 'what went live', { floor: 'release.live_month' }], ['Ready to go', 'signed off, waiting to go live', { source: 'gate_approvals' }]],
     },
     treasury: {
       holds: 'The budget, and who gets paid for what.', rule: 'majority', cap: 7,
       growth: 'Each new spending line takes a floor.', annex: 'room for an annex of spending lines',
-      floors: [['Builder rewards', 'paid for shipped work', { floor: 'treasury.rewards' }], ['AI grading', 'the reviewer that grades every ship', { floor: 'treasury.grading' }], ['Hosting', 'servers and storage', { floor: 'treasury.hosting' }], ['Reserve', 'what is left this month', { reading: 'money' }], ['Spending matters', 'spending put to a vote', { source: 'treasury_spending' }]],
+      floors: [['Builder rewards', 'paid for shipped work', { floor: 'treasury.rewards' }], ['AI grading', 'the reviewer that grades every ship', { floor: 'treasury.grading' }], ['Hosting', 'servers and storage', { floor: 'treasury.hosting', desk: 'treasury.backup' }], ['Reserve', 'what is left this month', { reading: 'money', desk: 'treasury.budgets' }], ['Spending matters', 'spending put to a vote', { source: 'treasury_spending' }]],
     },
   });
   const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];