@bongos/core 1.21.54 → 1.21.55

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

@@ -171,9 +171,11 @@
     withdraw: 'withdraw',
     // task 1004566: a module version flagged by its security check, checked again
     recheck: 'check again',
+    // task 1004580: a work category renamed, retired, brought back, or a new one added
+    rename: 'rename', retire: 'retire', restore: 'bring back', add: 'add',
   });
   // What a row's chips ask, per act (a reason or an option is one tap, never text).
-  const ASKS = Object.freeze({ recheck: 'why', 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', record: 'the recording', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom' });
+  const ASKS = Object.freeze({ recheck: 'why', 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', record: 'the recording', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom', rename: 'new name', add: 'its name' });
   // 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',
@@ -330,6 +332,9 @@
 
   // 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.
+  // Task 1004580: a row that `stay`s is edited in place, not decided, so an act
+  // leaves it on the desk; a rename's field starts from its whole name; a row
+  // with a `seq` (a place in an order) is moved from its open detail.
   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));
@@ -343,13 +348,45 @@
     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), {
+    const acted = actedRow(d.acts || [], card || { href: null }, ctx);
+    if (acted.choices.rename && acted.choices.rename.field) acted.choices.rename.value = full;
+    return Object.assign(acted, {
       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,
+      stay: d.stay === true, seq: Number.isInteger(d.seq) ? d.seq : null,
     });
   }
+  // The rows of one floor that hold a place (`seq`), in their order: each learns
+  // whether it can move up or down (task 1004580).
+  function placed(rows) {
+    const set = rows.filter((r) => r.seq != null);
+    set.forEach((r, i) => { r.moves = { up: i > 0, down: i < set.length - 1 }; });
+    return rows;
+  }
+  // The writes that move one placed row a place up (-1) or down (+1): one, when a
+  // whole number sits between its new neighbours' places; else every place
+  // numbered again in tens, writing only those that change. [{ id, sort_order }],
+  // [] at an end. Pure (task 1004580).
+  function placeMoves(rows, key, by) {
+    const set = (rows || []).filter((r) => r && r.seq != null && r.card && r.card.subject);
+    const i = set.findIndex((r) => r.key === key);
+    const j = i + by;
+    if (i < 0 || (by !== -1 && by !== 1) || j < 0 || j >= set.length) return [];
+    const order = set.slice();
+    order.splice(i, 1);
+    order.splice(j, 0, set[i]);
+    const lo = j > 0 ? order[j - 1].seq : null;
+    const hi = j < order.length - 1 ? order[j + 1].seq : null;
+    let v = null;
+    if (lo == null) v = hi - 10;
+    else if (hi == null) v = lo + 10;
+    else if (hi - lo >= 2) v = Math.floor((lo + hi) / 2);
+    if (v != null) return [{ id: str(set[i].card.subject.id), sort_order: v }];
+    return order.map((r, k) => ({ id: str(r.card.subject.id), sort_order: (k + 1) * 10, was: r.seq }))
+      .filter((p) => p.sort_order !== p.was).map((p) => ({ id: p.id, sort_order: p.sort_order }));
+  }
   // 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];
@@ -364,7 +401,7 @@
   function rowsFor(key, floor, docket, ctx) {
     const c = Object.assign({ docket: docket }, ctx || {});
     const done = c.done || {};
-    const desked = deskRows(key, floor, docket).filter((d) => !done[str(d.id)]).map((d) => deskRowOf(d, c)).filter((r) => r.actions.length);
+    const desked = placed(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);
@@ -592,7 +629,7 @@
 
   const api = {
     LIMITS: LIMITS, ACT_WORDS: ACT_WORDS, ASKS: ASKS, DESK_NOUNS: DESK_NOUNS, CHIPS: CHIPS, NOUNS: NOUNS, CLEAR: CLEAR,
-    fit: fit, ageWord: ageWord, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, cardFor: cardFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips, moved: moved,
+    fit: fit, ageWord: ageWord, placeMoves: placeMoves, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, cardFor: cardFor, 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.css

@@ -343,6 +343,8 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .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; }
+/* a place in an order moves from the open detail: its two chips wrap together (task 1004580) */
+.desk-moves { display: inline-flex; gap: 8px; flex-wrap: wrap; }
 .desk-choices__ask { font-size: 12.5px; color: var(--ink-faint); margin-right: 4px; }
 .desk-quiet { min-height: 168px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 12px; border-top: 1px solid var(--street-rule); text-align: center; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
 .desk-quiet__tick { display: block; fill: none; stroke: var(--ink); stroke-width: 1.4; stroke-linecap: round; animation: desk-pop 420ms cubic-bezier(.2,.7,.3,1) both; }

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

@@ -691,6 +691,13 @@
       // 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;
@@ -709,12 +716,14 @@
       }
       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);
@@ -724,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;
@@ -788,6 +831,8 @@
     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', 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 }); }
@@ -868,15 +913,20 @@
       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);
     };
+    // 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();
@@ -884,6 +934,11 @@
       desk.busy = 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);

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

@@ -83,3 +83,16 @@ Owner decision 2026-10-04: "all these processes should be integrated". The recor
 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.54",
+  "version": "1.21.55",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.54",
+      "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.54",
+  "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

@@ -9096,5 +9096,11 @@
       "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.54'; // 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;
+  }
+});