@bongos/core 1.21.53 → 1.21.55

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

@@ -51,6 +51,14 @@
 // for the day in this browser), a row that clears away (a CSS class, then the
 // redraw), a cleared floor that lights its windows and shows a tick in the
 // drawing, and the toast after every act.
+//
+// THE RECORDED SIGN-OFF (task 1004579). 'record it' on a promise that needs a
+// recording opens its one line on the desk row or the card: pick or drop the
+// video, "tested it live" sends it (its progress painted on that line in place)
+// and signs off, through GovMatterCard.recordRun and the goal page's own two
+// routes. Signed off, it is answered like every other act: the row clears, the
+// meter takes a pip, the toast speaks, the record gains the line. Refused, the
+// line says why and offers to try again; nothing is counted.
 
 (function () {
   'use strict';
@@ -67,6 +75,7 @@
     tasks: function (goalId) { return '/api/bongos/tasks?goal_id=' + encodeURIComponent(goalId); },
     room: '/api/bongos/government/board/items',
     constitution: '/api/bongos/government/constitution',
+    uat: function (id) { return '/api/bongos/done-when/' + encodeURIComponent(id) + '/uat'; },
   };
   var NARROW = 900;
   var I = window.GovInside;
@@ -88,6 +97,10 @@
   // the floors you cleared, the row whose facts or chips are open
   // 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 };
+  // the recorded sign-off (task 1004579), per matter: its file and phase
+  // (GovMatterCard.recordLine), the painter of its line as last drawn, and the
+  // checks read from GET /done-when/:id/uat (null reading, false unreadable)
+  var rec = { state: {}, paint: {}, checks: {} };
   var TODAY_KEY = 'gov-desk-today';
   var today = { day: '', n: 0 };
   var todayDrawn = null; // the count the meter's pips last drew: they are rebuilt only when it moves
@@ -623,7 +636,11 @@
     name.setAttribute('data-matter', r.matter);
     name.appendChild(node('span', 'desk-name__t', r.name));
     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'); });
+    name.addEventListener('click', function () {
+      desk.open = desk.open === r.key ? null : r.key; desk.ask = null;
+      if (desk.open && recorded(r)) readChecks(criterionOf(r.card));
+      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) {
@@ -660,9 +677,27 @@
     });
     main.appendChild(acts);
     row.appendChild(main);
+    if (recorded(r)) {
+      // a recording dropped anywhere on its row is taken, and its line opens
+      row.addEventListener('dragover', function (e) { if (e && e.preventDefault) e.preventDefault(); });
+      row.addEventListener('drop', function (e) {
+        if (e && e.preventDefault) e.preventDefault();
+        var f = e && e.dataTransfer && e.dataTransfer.files ? e.dataTransfer.files[0] : null;
+        if (f && !desk.busy) deskPick(r, f);
+      });
+    }
     if (desk.open === r.key) {
       var facts = node('div', 'desk-facts');
-      r.facts.forEach(function (f) { facts.appendChild(node('span', 'desk-fact', f)); });
+      // a recorded sign-off's detail is the goal page's three checks, once read
+      var checks = recorded(r) && rec.checks[criterionOf(r.card)];
+      (checks ? window.GovMatterCard.uatChecks(checks).facts : r.facts).forEach(function (f) { facts.appendChild(node('span', 'desk-fact', f)); });
+      // a row with a place in an order moves from here, one place a tap (task 1004580)
+      if (r.moves) {
+        var moves = node('span', 'desk-moves');
+        if (r.moves.up) moves.appendChild(moveChip(r, -1));
+        if (r.moves.down) moves.appendChild(moveChip(r, 1));
+        facts.appendChild(moves);
+      }
       row.appendChild(facts);
     }
     var asked = desk.ask && desk.ask.indexOf(r.key + '|') === 0 ? (r.choices || {})[desk.ask.slice(r.key.length + 1)] : null;
@@ -671,14 +706,24 @@
     if (asked) {
       var chips = node('div', 'desk-choices');
       chips.appendChild(node('span', 'desk-choices__ask', asked.ask));
+      if (asked.file) {
+        var strip = window.GovMatterCard.recordStrip(document, recState(r.matter), {
+          pick: function (f) { deskPick(r, f); },
+          send: function () { deskRecord(r); },
+        }, 'desk', desk.busy);
+        rec.paint[r.matter] = strip;
+        chips.appendChild(strip.node);
+      }
       asked.options.forEach(function (c) { chips.appendChild(chipBtn('desk-chip--choice', c.label, function () { deskAct(r, asked.for, c.input); })); });
       if (asked.field) {
-        // the one typed value a desk takes: a name to invite (never a reason)
+        // the one typed value a desk takes: a name, to invite or to call a
+        // category (never a reason); a rename starts from the name it has
         var input = node('input', 'desk-field');
         input.setAttribute('type', 'text');
         input.setAttribute('aria-label', asked.ask);
         input.setAttribute('autocomplete', 'off');
         input.setAttribute('maxlength', '60');
+        if (asked.value) { input.setAttribute('value', asked.value); input.value = asked.value; }
         var send = function () { var v = input.value.trim(); if (v) deskAct(r, asked.for, { option: v, label: v }); };
         input.addEventListener('keydown', function (e) { if (e.key === 'Enter') send(); });
         chips.appendChild(input);
@@ -688,6 +733,40 @@
     }
     return row;
   }
+  // A place in an order, moved one step (task 1004580): the chip in a row's open
+  // detail, and the writes it sends — GovDesk.placeMoves works out the places,
+  // each written through the card's own request; the first refusal stops the run.
+  function moveChip(r, by) {
+    var b = chipBtn('desk-chip--choice', by < 0 ? 'move up' : 'move down', function () { deskMove(r, by); });
+    b.setAttribute('data-act', by < 0 ? 'move-up' : 'move-down');
+    return b;
+  }
+  function deskMove(r, by) {
+    var D = window.GovDesk, C = window.GovMatterCard;
+    var writes = D && desk.model ? D.placeMoves(desk.model.rows, r.key, by) : [];
+    if (!C || !writes.length) return Promise.resolve(false);
+    var go = function () {
+      var i = 0;
+      var next = function (last) {
+        if (i >= writes.length) return Promise.resolve(last);
+        var w = writes[i++];
+        var req = C.request({ subject: { kind: 'work_category', id: w.id } }, 'move', { sort_order: w.sort_order });
+        return send(req).then(function (out) {
+          if (!out.ok) { say(C.refusal(out.status, out.body), true); return out; }
+          return next(out);
+        });
+      };
+      return next({ ok: true, status: 200, body: {} });
+    };
+    return deskAct(r, 'move', { by: by }, go).then(function (done) {
+      desk.open = r.key;
+      draw();
+      var at = rowEl(r.key);
+      var again = findAct(at, by < 0 ? 'move-up' : 'move-down') || findAct(at, by < 0 ? 'move-down' : 'move-up');
+      if (again && again.focus) again.focus();
+      return done;
+    });
+  }
   // 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;
@@ -751,38 +830,115 @@
     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', withdraw: 'withdrew',
+    budget: 'set the limit of', unsign: 'undid', withdraw: 'withdrew', record: 'signed off',
+    // task 1004580: the work categories
+    rename: 'renamed', retire: 'retired', restore: 'brought back', add: 'added', move: 'moved',
   };
+  // ---------- the recorded sign-off (task 1004579) ----------
+  function recState(key) { return rec.state[key] || (rec.state[key] = { file: null, phase: 'empty', pct: 0 }); }
+  function recorded(r) { return !!(r && r.choices && r.choices.record && r.choices.record.file); }
+  function criterionOf(cv) { return cv && cv.subject && cv.subject.kind === 'criteria_uat' ? cv.subject.id : null; }
+  // the goal page's three checks, read once per promise for its detail
+  function readChecks(id) {
+    if (id == null || id === '' || rec.checks[id] !== undefined) return Promise.resolve();
+    rec.checks[id] = null;
+    return getJson(FEEDS.uat(id)).then(function (v) {
+      rec.checks[id] = v && v.checks ? v : false;
+      draw();
+      if (view.open) fillCard();
+    });
+  }
+  function upload(url, file, onPct) { return window.GovMatterCard.uploadXhr(window.XMLHttpRequest, url, file, onPct); }
+  // send it, then sign off; a phase change redraws its surface, progress only paints its line
+  function runRecord(key, id, redraw) {
+    return window.GovMatterCard.recordRun(id, recState(key), {
+      upload: upload, send: send,
+      change: function () { redraw(); },
+      progress: function (st) { var p = rec.paint[key]; if (p) p.paint(st); },
+    });
+  }
+  function focusAct(host, act) {
+    var b = findAct(host, act);
+    if (b && b.tagName && String(b.tagName).toLowerCase() === 'label' && b.children && b.children[1]) b = b.children[1];
+    if (b && b.focus) b.focus();
+  }
+  function rowEl(key) {
+    var list = deskRowsEl();
+    var rows = list ? list.children : [];
+    for (var i = 0; i < rows.length; i++) if (rows[i].getAttribute('data-row') === key) return rows[i];
+    return null;
+  }
+  function deskPick(r, f) {
+    window.GovMatterCard.recordPick(recState(r.matter), f);
+    desk.ask = r.key + '|record'; desk.open = null;
+    draw();
+    var at = rowEl(r.key);
+    focusAct(at, findAct(at, 'record-send') ? 'record-send' : 'record-pick');
+  }
+  function deskRecord(r) {
+    return deskAct(r, 'record', {}, function () { return runRecord(r.matter, criterionOf(r.card), draw); }).then(function (done) {
+      if (!done) { var at = rowEl(r.key); focusAct(at, findAct(at, 'record-send') ? 'record-send' : 'record-pick'); }
+      return done;
+    });
+  }
+  // the card's handlers for the same line, on the card's own matter
+  function cardRecord(cv) {
+    var subj = cv.row && cv.row.card ? cv.row.card : cv;
+    var key = String(cv.key);
+    var refocus = function () { focusAct($('streetCardBody'), findAct($('streetCardBody'), 'record-send') ? 'record-send' : 'record-pick'); };
+    return {
+      state: function () { return recState(key); },
+      painted: function (s) { rec.paint[key] = s; },
+      pick: function (f) { window.GovMatterCard.recordPick(recState(key), f); fillCard(); refocus(); },
+      send: function () {
+        return actOn('record', {}, function () { return runRecord(key, criterionOf(subj), function () { if (view.open) fillCard(); }); })
+          .then(function (done) { if (!done && view.open) refocus(); return done; });
+      },
+    };
+  }
   // 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
   // it, the meter takes a pip and the toast says what happened. An act that
   // records nothing (hold) clears the row for this visit and says it still waits.
-  function deskAct(r, key, input) {
+  // go: the act's own sender in place of its one request (the recorded
+  // sign-off's upload then sign-off); its refusal is said on its own line.
+  function deskAct(r, key, input, go) {
     var C = window.GovMatterCard, st = view.inside;
     if (!C || !st || !r.card || desk.busy) return Promise.resolve(false);
     var refused = C.check(r.card, key, input);
     if (refused) { say(refused, true); return Promise.resolve(false); }
     var k = st.key + ':' + (view.insideModel ? view.insideModel.selFloor : 0);
-    var req = C.request(r.card, key, input);
+    var req = go ? null : C.request(r.card, key, input);
     var settle = function (body) {
       var a = C.answer(r.card, key, body);
       // 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;
+      // what was added is named by what was typed, not by the row it was added from
+      var what = key === 'add' && input && input.label ? String(input.label) : r.name;
+      desk.mine[k] = [(sent ? 'sent to council:' : DONE_WORDS[key]) + ' ' + what].concat(desk.mine[k] || []);
+      // a row that stays (a category being edited) is not cleared away (task 1004580)
+      if (!r.stay) 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;
+      if (!r.stay && desk.model && !desk.model.rows.some(function (x) { return x.matter !== r.matter; })) desk.cleared[k] = true;
       if (st.floor == null && view.insideModel) st.floor = view.insideModel.selFloor;
       bumpToday();
       if (a.building && a.kind) card.answer = { building: a.building, matter: r.matter, kind: a.kind, at: Date.now() };
       say(a.toast || 'Done.', true);
     };
-    if (!req) return new Promise(function (res) { clearRow(r.key, function () { settle({}); draw(); res(true); }); });
+    // a row being edited with nothing to send (an empty name) does nothing
+    if (!req && !go && r.stay) return Promise.resolve(false);
+    if (!req && !go) return new Promise(function (res) { clearRow(r.key, function () { settle({}); draw(); res(true); }); });
     desk.busy = true;
     draw();
-    return send(req).then(function (out) {
+    return (go ? go() : send(req)).then(function (out) {
       desk.busy = false;
-      if (!out.ok) { say(C.refusal(out.status, out.body), true); draw(); return false; }
+      if (!out.ok) { if (!go) say(C.refusal(out.status, out.body), true); draw(); return false; }
+      if (go) delete rec.state[r.matter];
+      if (r.stay) {
+        settle(out.body);
+        draw();
+        return load().then(function () { return true; });
+      }
       return new Promise(function (res) {
         clearRow(r.key, function () {
           settle(out.body);
@@ -1081,12 +1237,14 @@
     var ctx = { room: data.room, constitution: data.constitution, now: Date.now(), goals: (data.goals || []).filter(function (g) { return g && g.status === 'open'; }), pick: card.pick };
     var cv = D && D.cardFor ? D.cardFor(view.open, data.docket, ctx) : C ? C.model({ docket: data.docket, key: view.open, room: data.room, constitution: data.constitution, now: Date.now() }) : null;
     if (!cv) { closeCard(false); return null; }
+    var recordable = !!(cv.row && cv.row.choices && cv.row.choices.record && cv.row.choices.record.file);
+    if (recordable) { var cid = criterionOf(cv.row.card); C.withChecks(cv, rec.checks[cid] || null, rec.checks[cid] === false); }
     card.cv = cv;
     $('streetCardWhere').textContent = cv.where;
     $('streetCardWhen').textContent = cv.when;
     $('streetCardTitle').textContent = cv.title;
     var pager = C.pager ? C.pager(card.page, view.open) : null;
-    C.render(document, $('streetCardBody'), cv, { act: actOn, openForm: openForm, ask: askFor, more: toggleMore, pick: pickQueued, page: turnPage }, { form: card.form, ask: card.ask, more: card.more, error: card.error, busy: card.busy, fresh: card.fresh, pager: pager });
+    C.render(document, $('streetCardBody'), cv, { act: actOn, openForm: openForm, ask: askFor, more: toggleMore, pick: pickQueued, page: turnPage, record: recordable ? cardRecord(cv) : null }, { form: card.form, ask: card.ask, more: card.more, error: card.error, busy: card.busy, fresh: card.fresh, pager: pager });
     var frame = $('streetCard'); if (frame) frame.setAttribute('data-more', card.more ? 'open' : 'closed');
     placeCard();
     return cv;
@@ -1100,6 +1258,8 @@
   }
   function toggleMore() {
     card.more = !card.more;
+    var cv = card.cv;
+    if (card.more && cv && cv.row && cv.row.choices && cv.row.choices.record) readChecks(criterionOf(cv.row.card));
     fillCard();
     var mb = $('streetCardBody'), t = mb && mb.querySelector ? mb.querySelector('[data-act="more"]') : null;
     if (t && t.focus) t.focus();
@@ -1206,20 +1366,22 @@
   // answered without a request.
   // An act from the card goes with the desk row's own card when a row stands
   // behind it (its subject: which route, the council's), else the model's.
-  function actOn(key, input) {
+  // go: the act's own sender (the recorded sign-off), whose refusal its line says
+  function actOn(key, input, go) {
     var C = window.GovMatterCard, cv = card.cv;
     if (!C || !cv || card.busy) return Promise.resolve(false);
     var subj = cv.row && cv.row.card ? cv.row.card : cv;
     var refused = C.check(subj, key, input);
     if (refused) { card.error = refused; fillCard(); return Promise.resolve(false); }
     card.error = '';
-    var req = C.request(subj, key, input);
-    if (!req) return Promise.resolve(answered(subj, key, {}, false));
+    var req = go ? null : C.request(subj, key, input);
+    if (!req && !go) return Promise.resolve(answered(subj, key, {}, false));
     card.busy = true;
     fillCard();
-    return send(req).then(function (out) {
+    return (go ? go() : send(req)).then(function (out) {
       card.busy = false;
-      if (!out.ok) { card.error = C.refusal(out.status, out.body); if (view.open) fillCard(); return false; }
+      if (!out.ok) { if (!go) card.error = C.refusal(out.status, out.body); if (view.open) fillCard(); return false; }
+      if (go) { delete rec.state[String(cv.key)]; desk.done[String(cv.key)] = true; }
       return answered(subj, key, out.body, true);
     });
   }

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

@@ -652,7 +652,7 @@
     },
     "desk-rules": {
       "auth": true,
-      "_": "Task 1004559: Rules in force. The rot timer as day chips, work categories as a link, each module on or off.",
+      "_": "Task 1004559: Rules in force. The rot timer as day chips, each module on or off. Task 1004580: each work category is its own row, edited in place (no link out).",
       "url": "/builders/street#building=rules",
       "actions": [
         [
@@ -682,6 +682,46 @@
         ]
       }
     },
+    "desk-rules-category": {
+      "auth": true,
+      "_": "Task 1004580: a work category opened in place: its key, its place in the order and whether it is offered, with move up and move down.",
+      "url": "/builders/street#building=rules",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"0\"]"
+        ],
+        [
+          "wait",
+          600
+        ],
+        [
+          "click",
+          "[data-matter=\"rules.settings:cat-3\"]"
+        ],
+        [
+          "wait",
+          400
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-facts"
+        ]
+      }
+    },
     "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.",

package/modules/hall-ui/records/governor-street.md

@@ -68,3 +68,31 @@ Left on purpose, not counted as differences:
 - **The city sits inside the hall's shell** (sidebar and top bar). The prototype's home page carries only the wordmark, the switch, one button and one line; standalone hall pages were retired by task 1002868, and the city page adopted the shell after its record was written.
 - **The home line never says "pieces of work stuck at Review".** The prototype adds it while Review is a vacant lot; the city draws Review as held in this project (the header of `city-draw.js`), so the clause has nothing to stand on.
 - **Open owner choices met on the walk, untouched:** the "1" on a single-item pin, the light-mode legend hint wording, the recording sign-off going to its page, failed passed-vote actions on the record, a Discord update on withdraw, and the Work categories link.
+
+## The recorded sign-off, from the card (task 1004579)
+
+Owner decision 2026-10-04: "all these processes should be integrated". The recorded sign-off was the one Review row whose act still left for the goal page (the open choice both walkthroughs above left as found). It is done in place now, on the desk row and on the street card alike, through the same two routes the goal page uses (`POST /done-when/:id/uat/recording` with the raw video, then `POST /done-when/:id/uat` with the stored name). No new server path and no database change: the docket still hands the row `record`; only the page reads it differently.
+
+- **One line, the boards' chip style.** The boards draw no upload, so the card was extended in their own words: "record it" opens the row's choice line ("the recording"), the way a reason's chips open. The line says one thing at a time: "mp4 or webm, up to 100 MB" with "pick or drop it"; then the file and its size with "pick another" and "tested it live"; then "42% sent" over a hairline bar; then "sent, signing off…". The file chip is a label wrapping the real file input, so a tap opens the chooser and the keyboard reaches it; a file dropped anywhere on the row (or on the card's line) is taken too.
+- **"tested it live" is the attestation and the send.** The server needs the signer's word that they tried it on the live site when it cannot read the deploy itself; the goal page asked with a checkbox, the card asks with the same one-tap chip the backend-only sign-off already uses. The goal page's optional note is not carried: a typed note is not a chip.
+- **Progress paints the line in place.** The upload goes by XMLHttpRequest (fetch cannot report an upload's progress), and each tick moves only the line's text and the bar, never a redraw of the desk. The bar stops at 99% until the server answers.
+- **A refusal is one sentence on the line.** A wrong file is caught before anything is sent; the server's refusals map to short words ("Over the 100 MB cap. Record a shorter pass.", "You built this, so someone else signs it off.", "It is not on the live site yet. Sign off once it is.", "The upload broke off. Try again."). The line offers "try again" when trying again can work, "pick another" when the file was the problem, and nothing when no try can (you built it, already signed off). An upload that went through is kept, so a retry after a refused sign-off does not send the video twice. A refusal counts nothing and claims nothing in a toast.
+- **Signed off, it is answered like every other act.** The row clears away, the today meter takes a pip, the desk's toast says "Signed off with the recording. The promise counts as kept." (or that the goal is achieved), and the record gains "signed off …". From the street card the card closes and the Review building rises.
+- **"more" is the goal page's detail.** Opening the row's name, or "more" on the card, reads `GET /done-when/:id/uat` once and shows its three checks: the code (every linked task done), live (running, not yet, or the site cannot tell), and the sign-off (not yet, or an earlier one that lapsed). The earlier recording's video player is not drawn on the card.
+
+Walked in the hall preview harness at 1440 and 375, light and dark, desk and card: the empty line, a picked file, progress mid-upload, a refused file, a broken upload and its retry, the checks under "more", and the cleared row with pip, toast and record line. The harness docket holds no recorded criterion and refuses writes, so the walk added one recorded matter and answered the upload and the sign-off inside the page; nothing was signed off on the live site.
+
+Tests: `tests/hall_street_desk.mjs` (the `1004579` cases) hold the line in every phase, the routes against the goal page's and the server's own, the short refusals, the run's two steps and its retry rules, the upload with its progress, and on the page the desk row and the card end to end: the cleared row, the pip, the toast and the record line, a refused upload and a refused sign-off that keep the row and count nothing, the drop, and the checks.
+
+## Work categories, edited in place (task 1004580)
+
+Owner decision 2026-10-04: Work categories was the last floor row that still left the building (the link-out both walkthroughs above left as found). The Rules in force desk now edits the category set in place, through the same two routes the Project settings page uses: `PATCH /work-categories/:id` (project.settings.manage) and `POST /work-categories` (goal.create). No new route and no database change; the docket gained one read (`countGoalsByCategory`, how many goals carry each category) and two optional desk-row fields (`seq`, `stay`), and a desk may now type a `name` as well as a GitHub name.
+
+- **One row per category.** Its name and one fact: how many goals carry it (a retired one says "retired · N goals"). Offered ones come first, in their order, then the retired ones. Two buttons: rename and retire, or bring back and rename for a retired one. A "New category" row at the end adds one; it is offered only to a viewer holding goal.create, the add route's own atom.
+- **Rename and add type a name, nothing else.** The field opens on the row's choice line, the rot timer's way; a rename starts from the name it has. Retire and bring back are one tap (both are undone by the other).
+- **"more" is the page's detail.** Tapping a name opens its key, its place ("3 of 6 in order") and whether new goals are offered it, with "move up" and "move down" chips that wrap together. A move is one write when a whole number sits between its new neighbours' places, else the offered set is numbered again in tens, writing only the ones that change (`GovDesk.placeMoves`); the first refusal stops the run.
+- **A category row stays.** It is a thing being edited, not a matter decided, so an act does not clear it away (`stay`); the meter still takes a pip, the desk's toast speaks and the record gains "renamed …", "retired …", "moved …" or "added <the typed name>". A refused act says the server's reason, keeps the row and counts nothing.
+
+Walked in the hall preview harness at 1440 and 375, light and dark: the rows, an open detail with its move chips, the rename and add fields, and a rename sent (the write answered inside the page, since the harness refuses writes) with its pip, toast and record line. Nothing was changed on the live site. The old Project settings page keeps its own category list.
+
+Tests: `tests/hall_street_desk.mjs` (the `1004580` cases) hold the server rows and their gates, every act's route, the move arithmetic, and on the page rename, retire and bring back, a move from the open detail, an add, and a refused act and a refused move that count nothing. `tests/goal_category.mjs` holds the grouped count.

package/modules/lifecycle/goal-category.js

@@ -81,6 +81,20 @@ async function listCategories({ includeInactive = false } = {}, deps = {}) {
   return rows;
 }
 
+// How many goals carry each category, as a Map of id → count (task 1004580: the
+// Rules desk's one fact per category row). One grouped read for the whole set; a
+// category no goal carries is simply absent (read it as 0).
+async function countGoalsByCategory(deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const { rows } = await activePool.query(
+    `SELECT category_id, COUNT(*)::int AS n
+       FROM goals
+      WHERE category_id IS NOT NULL
+      GROUP BY category_id`
+  );
+  return new Map(rows.map((r) => [String(r.category_id), Number(r.n) || 0]));
+}
+
 async function getCategory(id, deps = {}) {
   const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
   const { rows } = await activePool.query(
@@ -369,6 +383,7 @@ module.exports = {
   slugify,
   isValidSlug,
   listCategories,
+  countGoalsByCategory,
   getCategory,
   adviseCategory,
   createCategory,

package/modules/lifecycle/routes/project-settings.js

@@ -135,23 +135,58 @@ function upmarketRow() {
 }
 
 // The Rules desk's settings rows (task 1004559), under this page's own atom: the
-// rot timer as one-tap day counts (PATCH /project-settings/rot-days), and the
-// work categories as a link to this page, since a category is named in words.
+// rot timer as one-tap day counts (PATCH /project-settings/rot-days), then the
+// work categories edited in place (task 1004580), so the desk no longer links
+// out to this page. Each category is a row: its name, how many goals carry it,
+// and the acts this page's category list has, each sent to the SAME route the
+// page uses — rename (a typed name) and retire / bring back through
+// PATCH /work-categories/:id (project.settings.manage), its place in the order
+// (`seq`, the sort_order the desk moves it by, given only to an offered one),
+// and a "New category" row whose name goes to POST /work-categories, offered only
+// to a viewer holding that route's own atom (goal.create). Offered categories
+// first, in their order, then the retired ones. `stay`: a category row stays on
+// the desk after an act (it is a thing being edited, not a matter decided).
 // Pure; exported for tests.
 const ROT_CHOICES = Object.freeze([7, 14, 30, 60, 90]);
-function settingsDeskRows({ days, categories }) {
-  const live = (categories || []).filter((c) => c && c.active !== false).length;
+function categoryRows(categories, { goals = new Map(), mayAdd = false } = {}) {
+  const all = (categories || []).filter((c) => c && c.id != null && c.label);
+  const live = all.filter((c) => c.active !== false);
+  const off = all.filter((c) => c.active === false);
+  const count = (c) => Number((goals instanceof Map ? goals.get(String(c.id)) : 0) || 0);
+  const goalWords = (n) => `${n} ${n === 1 ? 'goal' : 'goals'}`;
+  const rows = live.map((c, i) => ({
+    id: `cat-${c.id}`, name: c.label, fact: goalWords(count(c)),
+    facts: [`key ${c.slug}`, `${i + 1} of ${live.length} in order`, 'offered to new goals'],
+    tool: true, stay: true, seq: Number(c.sort_order), ref: { type: 'work_category', id: c.id },
+    acts: [{ key: 'rename', field: 'name' }, { key: 'retire' }],
+  })).concat(off.map((c) => ({
+    id: `cat-${c.id}`, name: c.label, fact: `retired · ${goalWords(count(c))}`,
+    facts: [`key ${c.slug}`, 'not offered to new goals', 'goals keep it'],
+    tool: true, stay: true, ref: { type: 'work_category', id: c.id },
+    acts: [{ key: 'restore' }, { key: 'rename', field: 'name' }],
+  })));
+  if (mayAdd) {
+    rows.push({ id: 'cat-new', name: 'New category', fact: `${live.length} in use`, facts: ['it gates nothing'], tool: true, stay: true, ref: { type: 'work_category', id: 'new' }, acts: [{ key: 'add', field: 'name' }] });
+  }
+  return rows;
+}
+function settingsDeskRows({ days, categories, goals, mayAdd = false }) {
   return [
     { id: 'rot', name: 'Rot timer', fact: `stale after ${days} ${days === 1 ? 'day' : 'days'}`, facts: ['raising it only asks a person'], tool: true, ref: { type: 'project_setting', id: 'rot_days' },
       acts: [{ key: 'rot', options: ROT_CHOICES.filter((d) => d !== Number(days)).slice(0, 4).map((d) => ({ key: String(d), label: `${d} days` })) }] },
-    { id: 'categories', name: 'Work categories', fact: `${live} in use`, tool: true, href: '/project-settings', ref: { type: 'project_setting', id: 'work_categories' }, acts: [{ key: 'open' }] },
-  ];
+  ].concat(categoryRows(categories, { goals, mayAdd }));
 }
 function contributeSettingsDesk() {
   api.contribute('governor.docket', {
     desk: 'rules.settings',
     gate: { permission: 'project.settings.manage' },
-    read: async () => settingsDeskRows({ days: (await api.resolveRotDays()).days, categories: await goalCategory.listCategories({ includeInactive: true }) }),
+    read: async (ctx) => settingsDeskRows({
+      days: (await api.resolveRotDays()).days,
+      categories: await goalCategory.listCategories({ includeInactive: true }),
+      goals: await goalCategory.countGoalsByCategory(),
+      // the add row only for a viewer POST /work-categories would let in
+      mayAdd: !!(ctx && typeof ctx.has === 'function' && ctx.has('goal.create')),
+    }),
   });
 }
 

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.53",
+  "version": "1.21.55",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.53",
+      "version": "1.21.55",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.53",
+  "version": "1.21.55",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -9086,5 +9086,21 @@
       "id": "1004498",
       "text": "Ideating mode now has its own tool. An \"Ideas\" button in the top bar opens a side panel where an ideator writes about the page they are on. \"Turn into ideas\" has an AI split the text into separate ideas, each filed under their"
     }
+  ],
+  "1.21.54": [
+    {
+      "id": "1004579",
+      "text": "A recorded sign-off is now done from the card, in place, inside the Review building. \"record it\" no longer sends you to the goal page: it opens one line where you pick or drop the walkthrough video, tap \"tested it live\", watch"
+    },
+    {
+      "id": "1002973",
+      "text": "A single test now checks every privacy rule at once — who can see a private, hidden or not-yet-active account on every page that shows people — so a change that breaks one rule fails straight away."
+    }
+  ],
+  "1.21.55": [
+    {
+      "id": "1004580",
+      "text": "Work categories can now be managed right on the Rules floor of the Governor City, with no trip to the old settings page. Each category is its own line showing how many goals use it. You can rename it, retire it or bring it bac"
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.53'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.55'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/goal_category.mjs

@@ -225,3 +225,19 @@ test('POST /goals accepts a category but never requires one', () => {
   assert.match(routes, /category_id: \{ type: 'integer', min: 1 \}/, 'accepted on create');
   assert.equal(/category_id: \{ required: true/.test(routes), false, 'never required — that would make the prompt a refusal');
 });
+
+test('countGoalsByCategory: one grouped read, id to count, for the Rules desk fact (task 1004580)', async () => {
+  const before = process.env.NODE_ENV;
+  process.env.NODE_ENV = 'test';
+  const seen = [];
+  const pool = { query: async (sql) => { seen.push(sql); return { rows: [{ category_id: 3, n: 4 }, { category_id: '7', n: '1' }] }; } };
+  try {
+    const m = await gc.countGoalsByCategory({ pool });
+    assert.deepEqual([...m.entries()], [['3', 4], ['7', 1]]);
+    assert.equal(seen.length, 1);
+    assert.match(seen[0], /GROUP BY category_id/);
+    assert.match(seen[0], /WHERE category_id IS NOT NULL/);
+  } finally {
+    if (before === undefined) delete process.env.NODE_ENV; else process.env.NODE_ENV = before;
+  }
+});