@bongos/core 1.21.35 → 1.21.36

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';
@@ -346,7 +348,8 @@
     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,
@@ -356,7 +359,7 @@
     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,
@@ -366,7 +369,7 @@
     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', desk: 'treasury.backup' }], ['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'];

package/modules/hall-ui/public/street.css

@@ -314,6 +314,18 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .desk-chip:hover { filter: brightness(1.08); }
 .desk-chip[disabled] { opacity: 0.55; cursor: progress; }
 .desk-wait { font-size: 13px; color: var(--ink-faint); border: 1px dashed var(--street-rule-strong); border-radius: 999px; padding: 6px 12px; white-space: nowrap; }
+/* the Planning desks (task 1004560): a goal's place in the order, its promise
+   pips (or a vote's seats), the two arrows, and the save bar under a moved order */
+.desk-pos { width: 22px; flex: none; font-size: 13px; color: var(--ink-faint); font-variant-numeric: tabular-nums; }
+.desk-pips { display: flex; gap: 4px; flex: none; }
+.desk-pip { width: 12px; height: 12px; border-radius: 3px; box-sizing: border-box; border: 1px solid var(--street-rule-strong); }
+.desk-pip--on { background: var(--ink); border-color: var(--ink); }
+.desk-arrow { width: 34px; height: 34px; flex: none; border-radius: 999px; border: 1px solid var(--street-rule-strong); background: none; color: var(--ink); cursor: pointer; display: inline-flex; align-items: center; justify-content: center; padding: 0; }
+.desk-arrow svg { fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; }
+.desk-arrow[disabled] { opacity: 0.55; cursor: progress; }
+.desk-arrow:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }
+.desk-save { display: flex; align-items: center; flex-wrap: wrap; gap: 10px 14px; padding: 16px 0 0; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
+.desk-save__line { font-size: 13.5px; color: var(--ink-soft); margin-right: auto; }
 .desk-facts, .desk-choices { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; padding: 10px 0 2px 52px; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
 .desk-fact { font-size: 13px; color: var(--ink-soft); background: var(--street-wash); border-radius: 6px; padding: 6px 10px; white-space: nowrap; }
 .desk-choices__ask { font-size: 12.5px; color: var(--ink-faint); margin-right: 4px; }
@@ -373,6 +385,9 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
   .inside-gov__row { flex-wrap: wrap; row-gap: 4px; }
   .desk-row__main { flex-wrap: wrap; row-gap: 8px; }
   .desk-name { flex-basis: calc(100% - 52px); }
+  .desk-pos ~ .desk-name { flex-basis: calc(100% - 88px); }
+  .desk-pos ~ .desk-pips { margin-left: 88px; }
+  .desk-pips ~ .desk-acts { margin-left: auto; }
   .desk-acts { margin-left: 52px; }
   .desk-facts, .desk-choices { padding-left: 0; }
   .desk-tile { min-width: 0; padding: 10px 14px; }

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

@@ -82,7 +82,8 @@
   var view = { open: null, opener: null, model: null, scale: 1, mode: null, inside: null, insideModel: null };
   // the desk's own state: rows you acted on this visit, what you did per floor,
   // the floors you cleared, the row whose facts or chips are open
-  var desk = { done: {}, mine: {}, cleared: {}, open: null, ask: null, busy: false, roomAsked: false, model: null };
+  // order: the Priorities desk's order as the viewer has moved it, per floor (task 1004560)
+  var desk = { done: {}, mine: {}, cleared: {}, order: {}, open: null, ask: null, busy: false, roomAsked: false, model: null };
   var TODAY_KEY = 'gov-desk-today';
   var today = { day: '', n: 0 };
 
@@ -553,7 +554,7 @@
     var D = window.GovDesk, st = view.inside;
     if (!D || !st) return;
     var k = st.key + ':' + bv.selFloor;
-    var dm = D.deskModel({ key: st.key, floor: bv.selFloor, docket: data.docket, goals: (data.goals || []).filter(function (g) { return g && g.status === 'open'; }), now: Date.now(), room: data.room, constitution: data.constitution, done: desk.done, mine: desk.mine[k] || [], cleared: !!desk.cleared[k], today: today.n, sym: bv.sym });
+    var dm = D.deskModel({ key: st.key, floor: bv.selFloor, docket: data.docket, goals: (data.goals || []).filter(function (g) { return g && g.status === 'open'; }), now: Date.now(), room: data.room, constitution: data.constitution, done: desk.done, mine: desk.mine[k] || [], cleared: !!desk.cleared[k], today: today.n, sym: bv.sym, order: desk.order[k] || null });
     desk.model = dm;
     el.className = 'inside-open desk' + (dm.quiet ? ' desk--quiet' : '');
     el.setAttribute('data-desk', dm.key);
@@ -595,6 +596,14 @@
       dm.rows.forEach(function (r) { list.appendChild(deskRow(r)); });
       el.appendChild(list);
     }
+    // a changed order: what saving does, then undo and save (task 1004560)
+    if (dm.save) {
+      var bar = node('div', 'desk-save');
+      bar.appendChild(node('span', 'desk-save__line', dm.save.line));
+      bar.appendChild(chipBtn('desk-chip--quiet', 'undo', function () { desk.order[k] = null; draw(); }));
+      bar.appendChild(chipBtn('desk-chip--primary', dm.save.label, function () { saveOrder(dm, k); }));
+      el.appendChild(bar);
+    }
     // the record line: what you just did here, then what this building closed
     var rec = node('div', 'desk-record');
     rec.appendChild(node('span', 'desk-record__label', 'record'));
@@ -606,6 +615,7 @@
     var row = node('div', 'desk-row' + (r.needs ? ' desk-row--needs' : ''));
     row.setAttribute('data-row', r.key);
     var main = node('div', 'desk-row__main');
+    if (r.pos) main.appendChild(node('span', 'desk-pos', String(r.pos)));
     main.appendChild(node('span', 'desk-ini', r.ini));
     var name = node('button', 'desk-name');
     name.setAttribute('type', 'button');
@@ -615,10 +625,33 @@
     name.appendChild(node('span', 'desk-name__f', r.fact));
     name.addEventListener('click', function () { desk.open = desk.open === r.key ? null : r.key; desk.ask = null; draw(); focusRow(r.key, 'name'); });
     main.appendChild(name);
+    // promises kept of total, or a vote's seats: one pip each
+    if (r.pips && r.pips.length) {
+      var pips = node('span', 'desk-pips');
+      pips.setAttribute('aria-hidden', 'true');
+      r.pips.forEach(function (p) { pips.appendChild(node('span', 'desk-pip' + (p.on ? ' desk-pip--on' : ''))); });
+      main.appendChild(pips);
+    }
     var acts = node('span', 'desk-acts');
     if (r.wait) acts.appendChild(node('span', 'desk-wait', r.wait));
+    if (r.order) {
+      // the order's two arrows: the move is the viewer's until saved
+      [['up', -1, 'M6 15l6-6 6 6'], ['down', 1, 'M6 9l6 6 6-6']].forEach(function (m) {
+        if (!r.actions.some(function (a) { return a.key === m[0]; })) return;
+        var b = node('button', 'desk-arrow');
+        b.setAttribute('type', 'button');
+        b.setAttribute('aria-label', 'move ' + r.name + ' ' + m[0]);
+        // the top goal cannot go up, nor the last down
+        if (desk.busy || (m[1] < 0 && r.top) || (m[1] > 0 && r.bottom)) b.setAttribute('disabled', '');
+        b.appendChild(icon(m[2], null, 14));
+        b.addEventListener('click', function () { moveRow(r, m[1]); });
+        acts.appendChild(b);
+      });
+    }
     // the primary button sits rightmost, as on the board
-    r.actions.slice().reverse().forEach(function (a) {
+    // a row whose chips stand open is decided by its chip alone: no button for it
+    if (!r.order) r.actions.slice().reverse().forEach(function (a) {
+      if (r.show && a.key === r.show) return;
       acts.appendChild(chipBtn('desk-chip--' + a.tone, a.label, function () {
         if (a.go) { window.location.href = a.go; return; }
         if (a.ask) { var at = r.key + '|' + a.key; desk.ask = desk.ask === at ? null : at; desk.open = null; draw(); focusRow(r.key, 'chip'); return; }
@@ -633,6 +666,8 @@
       row.appendChild(facts);
     }
     var asked = desk.ask && desk.ask.indexOf(r.key + '|') === 0 ? (r.choices || {})[desk.ask.slice(r.key.length + 1)] : null;
+    // a blocker's options stand open: deciding it is picking one
+    if (!asked && r.show) asked = (r.choices || {})[r.show] || null;
     if (asked) {
       var chips = node('div', 'desk-choices');
       chips.appendChild(node('span', 'desk-choices__ask', asked.ask));
@@ -653,6 +688,35 @@
     }
     return row;
   }
+  // The Priorities desk (task 1004560): a move is kept in this visit until saved.
+  function moveRow(r, by) {
+    var D = window.GovDesk, st = view.inside;
+    if (!D || !st || !desk.model) return;
+    var k = st.key + ':' + (view.insideModel ? view.insideModel.selFloor : 0);
+    var now = desk.model.rows.filter(function (x) { return x.order; }).map(function (x) { return x.key; });
+    desk.order[k] = D.moved(now, r.key, by);
+    draw();
+    focusRow(r.key, 'arrow');
+  }
+  // Save: the order goes to POST /goals/reorder, or is filed for the council;
+  // the server's own checks decide either way.
+  function saveOrder(dm, k) {
+    var C = window.GovMatterCard;
+    var req = C && C.orderRequest ? C.orderRequest(dm.save) : null;
+    if (!req || desk.busy) return Promise.resolve(false);
+    desk.busy = true;
+    draw();
+    return send(req).then(function (out) {
+      desk.busy = false;
+      if (!out.ok) { say(C.refusal(out.status, out.body)); draw(); return false; }
+      desk.order[k] = null;
+      desk.mine[k] = [dm.save.council ? 'order sent to council' : 'order set'].concat(desk.mine[k] || []);
+      bumpToday();
+      say(dm.save.said);
+      draw();
+      return load().then(function () { return true; });
+    });
+  }
   function deskRowsEl() {
     var st = view.insideModel;
     var on = $(st && st.flipA ? 'insideOpenA' : 'insideOpenB');
@@ -667,6 +731,7 @@
       if (rows[i].getAttribute('data-row') !== key) continue;
       var main = rows[i].children[0];
       var target = what === 'chip' && rows[i].children[1] ? rows[i].children[1].children[1] : main && main.children[1];
+      if (what === 'arrow' && main) target = main.querySelector ? main.querySelector('.desk-arrow') : target;
       if (target && target.focus) target.focus();
       return;
     }
@@ -685,6 +750,8 @@
     switch_on: 'switched on', switch_off: 'switched off', allow: 'allowed', disallow: 'disallowed', first: 'put first',
     pause: 'paused', resume: 'resumed', tier: 'new tier', deactivate: 'deactivated', give: 'gave', take: 'took back',
     check: 'checked', rot: 'set', module_on: 'turned on', module_off: 'turned off', backup: 'backed up', invite: 'invited',
+    decide: 'decided', ratify: 'ratified', ratify_goal: 'made a goal of',
+    budget: 'set the limit of', unsign: 'undid',
   };
   // One act from a row: checked, sent through the card's own request (the
   // server's permission checks decide), then the row clears, the floor counts
@@ -699,7 +766,9 @@
     var req = C.request(r.card, key, input);
     var settle = function (body) {
       var a = C.answer(r.card, key, body);
-      desk.mine[k] = [DONE_WORDS[key] + ' ' + r.name].concat(desk.mine[k] || []);
+      // an act at a building a sitting decides went to it as a matter (task 1004561)
+      var sent = r.card.subject && r.card.subject.council && req && /\/government\/board\/matters$/.test(req.url);
+      desk.mine[k] = [(sent ? 'sent to council:' : DONE_WORDS[key]) + ' ' + r.name].concat(desk.mine[k] || []);
       desk.done[r.matter] = true;
       desk.open = null; desk.ask = null;
       if (desk.model && !desk.model.rows.some(function (x) { return x.matter !== r.matter; })) desk.cleared[k] = true;

package/modules/hall-ui/public/street.states.json

@@ -681,6 +681,130 @@
           ".desk-rows"
         ]
       }
+    },
+    "desk-planning-priorities": {
+      "auth": true,
+      "_": "Task 1004560: Planning, Priorities. The open goals in order with promise pips and two arrows; one goal moved down, so the save bar says the new order goes to the council and how many yes it needs, with undo.",
+      "url": "/builders/street#building=planning",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"0\"]"
+        ],
+        [
+          "wait",
+          600
+        ],
+        [
+          "click",
+          ".desk-arrow[aria-label$=\" down\"]"
+        ],
+        [
+          "wait",
+          400
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows",
+          ".desk-pips",
+          ".desk-save"
+        ]
+      }
+    },
+    "desk-planning-ideas": {
+      "auth": true,
+      "_": "Task 1004560: Planning, Ideas to ratify. A Full Idea in its vote with seat pips, a promise to ratify in one tap, and a carried Full Idea made a goal from a version chip.",
+      "url": "/builders/street#building=planning",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"1\"]"
+        ],
+        [
+          "wait",
+          600
+        ],
+        [
+          "focus",
+          ".desk-rows .desk-row:last-child .desk-name"
+        ],
+        [
+          "wait",
+          300
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows"
+        ]
+      }
+    },
+    "desk-planning-blockers": {
+      "auth": true,
+      "_": "Task 1004560: Planning, Waiting on you. Each blocker decided by one of its options as chips standing open; go ahead, not now, need more when it lists none.",
+      "url": "/builders/street#building=planning",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"2\"]"
+        ],
+        [
+          "wait",
+          600
+        ],
+        [
+          "focus",
+          ".desk-rows .desk-row:last-child .desk-name"
+        ],
+        [
+          "wait",
+          300
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows",
+          ".desk-choices",
+          ".desk-status--hot"
+        ]
+      }
     }
   },
   "reducedMotion": {

package/modules/ideas/governor-docket.js

@@ -19,6 +19,7 @@
 
 const api = require('../../src/module-api');
 const blockers = require('./blockers');
+const ratify = require('./ratify');
 
 const POINT = 'governor.docket';
 const DOCKET_BLOCKER_LIMIT = 50;
@@ -41,9 +42,96 @@ function blockerDocketMatter(b, mayResolve) {
     tally: null,
     href: `/blockers#blocker-${b.id}`,
     ref: { type: 'blocker', id: b.id },
+    // the floor desk's one act (task 1004560): decide, by one of its options
+    ...(mayResolve ? { acts: [{ key: 'decide', options: blockerOptions(b.body_md) }] } : {}),
   };
 }
 
+// A blocker's options as one-tap chips (task 1004560). Its own, when its body
+// lists them as "Option A: …" lines (two to five of them); otherwise the three
+// answers every blocker takes. The chosen key becomes the resolution note, so
+// a key is the option's own words (at most 64 characters) and the label its
+// first words. Pure.
+const DEFAULT_CHOICES = Object.freeze(['go ahead', 'not now', 'need more']);
+const OPTION_LINE = /^\s*(?:[-*]|\d+[.)])?\s*(?:\*\*)?option\s+[A-Za-z0-9]{1,2}(?:\*\*)?\s*[:.)—-]+\s*(?:\*\*)?(.+)$/i;
+function plainWords(s) { return String(s).replace(/[*_`[\]]+/g, '').replace(/\([^)]*\)/g, '').replace(/\s+/g, ' ').trim(); }
+function shortLabel(s) {
+  let out = '';
+  for (const w of s.split(' ')) { const next = out ? out + ' ' + w : w; if (next.length > 16) break; out = next; }
+  return out || s.slice(0, 16);
+}
+function blockerOptions(bodyMd) {
+  const found = [];
+  for (const line of String(bodyMd || '').split(/\r?\n/)) {
+    const m = OPTION_LINE.exec(line);
+    if (!m) continue;
+    const text = plainWords(m[1]).split(/\s[—–-]\s|[.;:]\s/)[0].trim();
+    if (text && !found.some((o) => o.key === text.slice(0, 64))) found.push({ key: text.slice(0, 64), label: shortLabel(text) });
+  }
+  if (found.length >= 2 && found.length <= 5) return found;
+  return DEFAULT_CHOICES.map((t) => ({ key: t, label: t }));
+}
+
+// The Ideas-to-ratify desk (task 1004560): the ideas a ratifier may take from
+// the floor, under idea.ratify (both ratify routes' atom). A criterion proposal
+// ratifies in one tap (POST /inbox/:id/ratify). A Full Idea the board has
+// carried becomes a goal (POST /inbox/:id/ratify-goal) with its target version
+// as a chip — only when its answers compose a goal on their own; one that needs
+// the ratifier to write its criterion opens its page instead. A Full Idea still
+// in its sitting is not here: it is the board's vote row (ADR 0175 §8). Pure.
+function ratifyDeskRows(ideas, versions, passed) {
+  const chips = (versions || []).slice(0, 5).map((v) => ({ key: String(v.id), label: String(v.id) }));
+  const out = [];
+  for (const i of ideas || []) {
+    if (!i || i.status !== 'open') continue;
+    const href = `/idea/${i.id}`;
+    if (i.kind === 'criterion-proposal') {
+      let p = null;
+      try { p = ratify.parseProposalBody(i.body_md); } catch (_) { p = null; }
+      if (!p || !p.target_version) continue;
+      out.push({
+        id: `p${i.id}`, name: String(i.title || 'a promise'), ref: { type: 'criterion_proposal', id: i.id }, href, opened_at: i.created_at,
+        fact: `a promise for ${p.target_version}`, facts: [String(p.criterion_md || '').slice(0, 80)],
+        acts: [{ key: 'ratify' }, { key: 'open' }],
+      });
+      continue;
+    }
+    if (i.grade !== 'full' || !passed.has(String(i.id))) continue;
+    const composed = ratify.composeGoalFromFullIdea({ ideaId: i.id, templateKey: i.template_key, fieldValues: i.field_values });
+    const fits = composed && composed.ok && chips.length > 0;
+    out.push({
+      id: `g${i.id}`, name: String(i.title || 'a full idea'), ref: { type: 'full_idea', id: i.id }, href, opened_at: i.created_at,
+      fact: 'the board carried it', facts: [fits ? 'becomes a goal' : 'needs its page to finish'],
+      acts: fits ? [{ key: 'ratify_goal', options: chips }, { key: 'open' }] : [{ key: 'open' }],
+    });
+  }
+  return out;
+}
+// The desk reads the oldest 30 open proposals and Full Ideas (older first, so
+// nothing waits forever behind newer ones); which Full Ideas the board carried
+// is one read for all of them (government.boardPassedIdeaIds).
+const RATIFY_IDEAS_LIMIT = 30;
+async function readRatifyDesk() {
+  const { rows: ideas } = await api.pool.query(
+    `SELECT i.id, i.title, i.kind, i.status, i.body_md, i.created_at,
+            COALESCE(g.grade, 'quick') AS grade, g.template_key, g.field_values
+       FROM idea_inbox i LEFT JOIN ideas_grades g ON g.idea_id = i.id
+      WHERE i.status = 'open' AND (i.kind = 'criterion-proposal' OR g.grade = 'full')
+      ORDER BY i.created_at, i.id LIMIT $1`,
+    [RATIFY_IDEAS_LIMIT],
+  );
+  const government = api.resolveOptional && api.resolveOptional('government');
+  const passed = new Set();
+  const full = ideas.filter((i) => i.grade === 'full').map((i) => i.id);
+  if (full.length && government && typeof government.boardPassedIdeaIds === 'function') {
+    (await government.boardPassedIdeaIds(full)).forEach((id) => passed.add(String(id)));
+  }
+  const { rows: versions } = passed.size
+    ? await api.pool.query(`SELECT id, name FROM versions WHERE status IN ('building', 'planning') ORDER BY (status = 'building') DESC, id LIMIT 5`)
+    : { rows: [] };
+  return ratifyDeskRows(ideas, versions, passed);
+}
+
 // The rules-at-work reading from this month's routed filings. Pure.
 function rulesReading(settledThisMonth) {
   const n = Number(settledThisMonth) || 0;
@@ -114,6 +202,7 @@ function contributeIdeasToDocket() {
       return rows.map((b) => blockerDocketMatter(b, mayResolve));
     },
   });
+  api.contribute(POINT, { desk: 'planning.ratify', gate: { permission: 'idea.ratify' }, read: () => readRatifyDesk() });
   // A count, no rows: any builder may read it.
   api.contribute(POINT, {
     reading: 'rules',
@@ -127,6 +216,8 @@ function contributeIdeasToDocket() {
 module.exports = {
   contributeIdeasToDocket,
   blockerDocketMatter,
+  blockerOptions,
+  ratifyDeskRows,
   rulesReading,
   rulesFloor,
   rulesHistory,

package/modules/lifecycle/governor-docket.js

@@ -181,6 +181,37 @@ function prioritiesFloor(goals, versionId) {
   return { count: '', line: 'the order goals are worked in', lines: [[top, versionId ? `version ${versionId}` : ''], [`${plural(mine.length, 'goal is', 'goals are')} in the order.`, '']], hot: false };
 }
 
+// The Priorities desk (task 1004560): the building version's open goals in their
+// worked order, each with its promises kept of total, for a viewer who may set
+// the order — POST /goals/reorder's own atom (goal.reorder), or, where Planning
+// is put to a sitting, the right to file the matter (board.item.open). Which of
+// the two a save takes is the decision table's call, read by the screen from the
+// docket's own buildings row; the route the save reaches still decides. Pure.
+const ORDER_PIPS = 12;
+function orderDeskRows(goals, criteria, versionId, mayOrder) {
+  if (!mayOrder || !versionId) return [];
+  const by = new Map();
+  for (const c of criteria || []) {
+    if (c.goal_id == null) continue;
+    const k = String(c.goal_id);
+    if (!by.has(k)) by.set(k, { kept: 0, total: 0 });
+    const e = by.get(k); e.total += 1; if (c.satisfied === true) e.kept += 1;
+  }
+  const mine = (goals || []).filter((g) => g && g.status === 'open' && g.version_id === versionId);
+  if (mine.length < 2) return []; // one goal has no order to set
+  return mine.map((g) => {
+    const e = by.get(String(g.id));
+    const of = e ? Math.min(e.total, ORDER_PIPS) : 0;
+    return {
+      id: g.id, name: String(g.title), ref: { type: 'goal', id: g.id }, set: String(versionId),
+      fact: e ? `${e.kept} of ${e.total} promises kept` : 'no promises yet',
+      facts: [`version ${versionId}`],
+      ...(of ? { pips: { on: Math.min(e.kept, of), of } } : {}),
+      acts: [{ key: 'up' }, { key: 'down' }],
+    };
+  });
+}
+
 // Planning · Versions: what is building, and the last that shipped.
 function versionsFloor(versions, goals) {
   const all = versions || [];
@@ -210,6 +241,26 @@ function signedOffFloor(criteria, now) {
   };
 }
 
+// The Review desk's signed-off rows (task 1004561): the newest promises signed
+// off, each with one act, undo, for a viewer holding criterion.unsatisfy (POST
+// /done-when/:id/unsatisfy's own atom). The reason is one tap. Pure.
+const UNDO_REASONS = Object.freeze([
+  { key: 'broke', label: 'it broke again' },
+  { key: 'untested', label: 'not truly tested' },
+  { key: 'error', label: 'signed in error' },
+]);
+const SIGNED_ROWS = 8;
+function signedDeskRows(criteria) {
+  return (criteria || []).filter((c) => c && c.satisfied === true && c.checked_at)
+    .sort((a, b) => Date.parse(b.checked_at) - Date.parse(a.checked_at))
+    .slice(0, SIGNED_ROWS)
+    .map((c) => ({
+      id: c.id, name: String(c.criterion_md), fact: `signed off ${dayWord(c.checked_at)}`,
+      facts: c.goal_title ? [String(c.goal_title)] : [], ref: { type: 'signed_criterion', id: c.id },
+      acts: [{ key: 'unsign', options: UNDO_REASONS }],
+    }));
+}
+
 // Release · Live this month: shipped work, newest first.
 function liveMonthFloor(shipped, now) {
   const month = (shipped || []).filter((t) => t.shipped_at && Date.parse(t.shipped_at) >= monthStart(now));
@@ -284,6 +335,15 @@ function contributeLifecycleFloors() {
     floor: 'planning.priorities', gate: any,
     read: async (_ctx, { once } = {}) => prioritiesFloor(await openGoals(once), await db.currentBuildingVersionId()),
   });
+  api.contribute(POINT, {
+    desk: 'planning.order', gate: any,
+    read: async (ctx, { once } = {}) => {
+      const may = ctx.has('goal.reorder') || ctx.has('board.item.open');
+      if (!may) return [];
+      const v = await db.currentBuildingVersionId();
+      return orderDeskRows(await openGoals(once), v ? await doneWhen.listCriteria(v) : [], v, may);
+    },
+  });
   api.contribute(POINT, {
     floor: 'planning.versions', gate: any,
     read: async () => versionsFloor(await db.listVersions(), await db.listGoals({})),
@@ -295,6 +355,13 @@ function contributeLifecycleFloors() {
       return signedOffFloor(v ? await doneWhen.listCriteria(v) : [], now);
     },
   });
+  api.contribute(POINT, {
+    desk: 'review.signed', gate: { permission: 'criterion.unsatisfy' },
+    read: async () => {
+      const v = await db.currentBuildingVersionId();
+      return signedDeskRows(v ? await doneWhen.listCriteria(v) : []);
+    },
+  });
   api.contribute(POINT, {
     floor: 'release.live_month', gate: any,
     read: async (_ctx, { now } = {}) => liveMonthFloor(await db.recentShippedTasks(SHIPPED_LIMIT, { days: 31 }), now),
@@ -398,8 +465,10 @@ module.exports = {
   promisesReading,
   goalsFloor,
   prioritiesFloor,
+  orderDeskRows,
   versionsFloor,
   signedOffFloor,
+  signedDeskRows,
   liveMonthFloor,
   heldBackFloor,
   newcomersFloor,

package/modules/lifecycle/matter-acts.js

@@ -0,0 +1,63 @@
+'use strict';
+
+// modules/lifecycle/matter-acts.js — what a PASSED Review or Release matter
+// carries out (task 1004561, goal 1000125). When a project's decision table puts
+// Review or Release to a sitting, its passed matter acts here, after the close
+// commits, through the SAME function the direct route calls:
+//   review  satisfy_criterion → satisfyByOverride   (POST /done-when/:id/satisfy)
+//   release approve_override  → db.decideOverrideRequest (POST /override-requests/:id/decide)
+//   release approve_gate      → approveGatePr       (POST /gate-approvals/:pr/approve)
+// The government module only checks the act's shape and calls in through the
+// 'governor.matterAct' contribution point (a module never requires a sibling).
+// Each act returns { done, reason? }: a refusal the route would give (already
+// decided, not open, owner only) is a reason, never a throw.
+
+const api = require('../../src/module-api');
+const db = require('./db');
+const doneWhen = require('./done-when');
+
+const POINT = 'governor.matterAct';
+const why = (area, ctx) => `A passed ${area} matter (matter ${ctx && ctx.matterId}) decided it.`;
+
+// Required lazily: the route files build routers, and only their shared
+// functions are needed here.
+const routes = {
+  doneWhen: () => require('./routes/done-when'),
+  gate: () => require('./routes/gate-approvals'),
+};
+
+const ACTS = Object.freeze({
+  review: Object.freeze({
+    satisfy_criterion: async (action, ctx) => {
+      const c = await doneWhen.getCriterion(action.criterion_id);
+      if (!c) return { done: false, reason: 'criterion_not_found' };
+      if (c.satisfied === true) return { done: false, reason: 'already_satisfied' };
+      await routes.doneWhen().satisfyByOverride({ criterionId: action.criterion_id, signerId: ctx.decidedBy, reason: why('Review', ctx) });
+      return { done: true };
+    },
+  }),
+  release: Object.freeze({
+    approve_override: async (action, ctx) => {
+      try {
+        await db.decideOverrideRequest({ requestId: action.request_id, archonId: ctx.decidedBy, decision: 'approve', note: why('Release', ctx) });
+        return { done: true };
+      } catch (err) {
+        if (err && err.code === 'REQUEST_NOT_OPEN') return { done: false, reason: 'request_not_open' };
+        if (err && err.code === 'OVERRIDE_OWNER_ONLY') return { done: false, reason: 'override_owner_only' };
+        throw err;
+      }
+    },
+    approve_gate: async (action, ctx) => {
+      const out = await routes.gate().approveGatePr({ number: action.pr, login: `council, matter ${ctx && ctx.matterId}` });
+      return out.ok ? { done: true } : { done: false, reason: out.code };
+    },
+  }),
+});
+
+function contributeLifecycleMatterActs() {
+  for (const [area, acts] of Object.entries(ACTS)) {
+    for (const [type, act] of Object.entries(acts)) api.contribute(POINT, { area, type, act });
+  }
+}
+
+module.exports = { ACTS, contributeLifecycleMatterActs };