@bongos/core 1.21.90 → 1.21.91

package/modules/hall-ui/public/craft-mode.js

@@ -196,6 +196,64 @@
     if (mark) mark.textContent = look;
   }
 
+  // ---------- Governing's header tallies (task 1004563) ----------
+  // "needs you N · moving M" beside the eyebrow, as on the four-mode prototype.
+  // Needs you is the open-blocker total GET /blockers already carries; moving is
+  // tasks being built or waiting to land (active + confirmed, owner 2026-10-08),
+  // counted by the server at GET /moving. Read once per page. A figure that cannot
+  // be read is LEFT OUT, never shown as 0: zero would say nothing waits on you.
+  var TALLY_API = '/api/bongos';
+  var tallyAsk = null;
+  function readCount(path, pick) {
+    if (typeof fetch !== 'function') return Promise.resolve(null);
+    return fetch(TALLY_API + path, { credentials: 'same-origin', headers: { Accept: 'application/json' } })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (j) {
+        var n = j ? pick(j) : null;
+        return (typeof n === 'number' && isFinite(n) && n >= 0) ? n : null;
+      }, function () { return null; });
+  }
+  function askTallies() {
+    if (!tallyAsk) {
+      tallyAsk = Promise.all([
+        readCount('/blockers?limit=1', function (j) { return j.page && j.page.total; }),
+        readCount('/moving', function (j) { return j.moving; }),
+      ]).then(function (v) { return { needs: v[0], moving: v[1] }; });
+    }
+    return tallyAsk;
+  }
+  function tallyHtml(t) {
+    var parts = [];
+    function one(label, n, due) {
+      return '<span class="craft-tally' + (due ? ' craft-tally--due' : '') + '">'
+        + '<span class="craft-tally__label">' + label + '</span> '
+        + '<span class="craft-tally__n">' + n + '</span></span>';
+    }
+    if (t && t.needs != null) parts.push(one('needs you', t.needs, t.needs > 0));
+    if (t && t.moving != null) parts.push(one('moving', t.moving, false));
+    return parts.join(' <span class="craft-tallies__sep" aria-hidden="true">·</span> ');
+  }
+  function applyTallies(mode) {
+    var box = document.getElementById('craft-tallies');
+    if (mode !== 'governing') { remove(box); return; }
+    var mark = document.getElementById('craft-eyebrow');
+    if (!box && mark && mark.parentNode) {
+      box = document.createElement('span');
+      box.id = 'craft-tallies';
+      box.className = 'craft-tallies';
+      box.setAttribute('hidden', '');
+      mark.parentNode.insertBefore(box, mark.nextSibling);
+    }
+    if (!box) return;
+    askTallies().then(function (t) {
+      var live = document.getElementById('craft-tallies');
+      if (!live || document.documentElement.dataset.craft !== 'governing') return;
+      var html = tallyHtml(t);
+      live.innerHTML = html;
+      if (html) live.removeAttribute('hidden'); else live.setAttribute('hidden', '');
+    });
+  }
+
   // ---------- each mode's tools (task 1004496 onward) ----------
   // Artistry has two: the palette (a feedback doc, page-notes.js) and the
   // paintbrush (the page's words as a wording change, paintbrush.js). Ideating
@@ -311,6 +369,7 @@
     if (sw) sw.classList.toggle('craft-switch--unset', !mode);
     applyNav();
     applyLook(mode);
+    applyTallies(mode);
     applyTools(mode);
     try { document.dispatchEvent(new CustomEvent('otb:craft', { detail: { mode: mode } })); } catch (_) { /* old engine */ }
   }
@@ -521,6 +580,7 @@
     applyNav: applyNav,
     LOOKS: LOOKS,
     artHtml: artHtml,
+    tallyHtml: tallyHtml,
     TOOLS: TOOLS,
     switchHtml: switchHtml,
     mount: mount,

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

@@ -1472,6 +1472,38 @@ html:is([data-craft="artistry"], [data-craft="ideating"], [data-craft="governing
   flex-shrink: 0;
 }
 @media (max-width: 640px) { .craft-eyebrow { display: none; } }
+/* Governing's header tallies (craft-mode.js applyTallies, task 1004563):
+   "needs you N · moving M" after the eyebrow. The warm dot marks needs-you only
+   while something waits. Hidden at <=960px, earlier than the eyebrow: below that
+   they squeeze the jump button under its own label (measured at 800px). */
+.craft-tallies {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 10px;
+  white-space: nowrap;
+  flex-shrink: 0;
+  font-size: 12px;
+}
+.craft-tallies[hidden] { display: none; }
+.craft-tally { display: inline-flex; align-items: baseline; gap: 6px; }
+.craft-tally__label {
+  font-family: var(--label-face);
+  font-size: 11px;
+  letter-spacing: .12em;
+  text-transform: uppercase;
+  color: var(--ink-soft);
+}
+.craft-tally__n { color: var(--ink); font-variant-numeric: tabular-nums; font-weight: 500; }
+.craft-tally--due::before {
+  content: '';
+  align-self: center;
+  width: 7px;
+  height: 7px;
+  border-radius: 999px;
+  background: var(--accent);
+}
+.craft-tallies__sep { color: var(--ink-faint); }
+@media (max-width: 960px) { .craft-tallies { display: none; } }
 /* The signature: the mode's door scene (craft-mode.js artHtml, the same art the
    picker draws) framed under the brand, 40px in the closed rail and 64px open.
    The 110px-tall scene is scaled to the plate's height and widened to fill it,

package/modules/hall-ui/records/craft-mode.md

@@ -34,7 +34,7 @@ Covers: every shelled hall page (`craft-mode.js`, `shell.js`, `style.css`), and
 - **The accent stays the action colour.** `--craft` paints only the switch's current pill, the current tab (tint, icon, label, marker) and the top bar's hairline.
 - **Two pieces are drawn by `craft-mode.js` `applyLook()`, on every mode change:** the eyebrow beside `#topbar-title` (`LOOKS`: "the studio · night", "the sky", "the city"; hidden at <=640px, where it overflowed phones) and the scene plate under `.app-sidebar__brand` (40px closed rail, 64px open). The plate's markup IS `artHtml(mode)`, the picker's door art, exported rather than copied; light mode recolours it to each scene's day (the city is the dark one through `invert(1) hue-rotate(180deg)`). It does not animate.
 - **Always-present tabs widened** (owner, 2026-10-03): `ALWAYS_TABS` is Builders, Collab and Profile, so every mode keeps the You and Community groups.
-- **Governing's header tallies** ("needs you · moving") are task 1004563, not this look.
+- **Governing's header tallies** (task 1004563): `applyTallies()` draws "needs you N · moving M" right after the eyebrow, Governing only, hidden at <=960px (below that they squeezed the jump button under its own label, measured at 800px). Needs you is `GET /blockers?limit=1`'s `page.total`; moving is `GET /moving` (lifecycle, tasks `active` + `confirmed`, owner 2026-10-08), a count in SQL so the page never pulls task rows. Read once per page; a figure that cannot be read is LEFT OUT, never drawn as 0. The warm dot marks needs-you only above zero. It toggles the `hidden` ATTRIBUTE, never `.hidden =` (the nav gate owns that property; `tests/craft_mode_nav.mjs`). Pinned by `tests/craft_mode_tallies.mjs`.
 
 ## The paintbrush (task 1004497)
 

package/modules/lifecycle/module.json

@@ -32,7 +32,8 @@
       "artist-gate",
       "removal-proposals",
       "sky",
-      "goal-task-relevance"
+      "goal-task-relevance",
+      "moving"
     ],
     "pollers": [
       "publish-reconciler"

package/modules/lifecycle/moving.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// modules/lifecycle/moving.js — how much of the project is MOVING right now, as one
+// count (task 1004563, goal 1000095 WA6).
+//
+// WHY. Governing mode's top bar reads "needs you N · moving M" (the four-mode
+// prototype the owner named the standard on 2026-10-03). "Needs you" already had
+// a source — the public open-blocker list carries its own total — but "moving" had
+// none, and the only way to get one from the browser was GET /tasks?status=…, which
+// returns every row with its whole description to produce a single number. That is
+// the read the hall's bounded-reads rule forbids (modules/hall-ui/CLAUDE.md: a Home
+// card asks the server for what it draws). So the number is counted here, in SQL.
+//
+// WHAT COUNTS (owner decision, 2026-10-08): a task being built right now plus a task
+// waiting to land — status `active` or `confirmed`. Not `completed` (a ship waiting on
+// its grade is neither being built nor queued to land) and nothing terminal. The two
+// halves come back separately as well as summed, so a caller can say which is which.
+//
+// MODULE BOUNDARY: reaches core only through the published doorway.
+
+const api = require('../../src/module-api');
+
+const MOVING_STATUSES = Object.freeze(['active', 'confirmed']);
+
+// → { moving, active, confirmed }. `deps.pool` is the #538 test seam, honoured only
+// under NODE_ENV==='test' like its siblings in this module.
+async function countMoving(deps = {}) {
+  const pool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : api.pool;
+  const { rows } = await pool.query(
+    `SELECT status, count(*)::int AS n
+       FROM tasks
+      WHERE status = ANY($1::text[])
+      GROUP BY status`,
+    [MOVING_STATUSES],
+  );
+  const by = Object.fromEntries(rows.map((r) => [r.status, Number(r.n) || 0]));
+  const active = by.active || 0;
+  const confirmed = by.confirmed || 0;
+  return { moving: active + confirmed, active, confirmed };
+}
+
+// The GET /moving handler, injectable so a test drives it with no express.
+function movingHandler({ log, count = countMoving } = {}) {
+  return async function movingRoute(_req, res) {
+    try {
+      res.set('Cache-Control', 'private, max-age=30');
+      res.json(await count());
+    } catch (err) {
+      if (log) log.error('GET /moving', err);
+      res.fail('moving_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+module.exports = { MOVING_STATUSES, countMoving, movingHandler };

package/modules/lifecycle/routes/moving.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// modules/lifecycle/routes/moving.js — GET /moving, how many tasks are being built or
+// waiting to land (task 1004563, goal 1000095 WA6).
+//
+// WHY ITS OWN ROUTE FILE. routes/tasks.js sits at the 1,500-line ratchet, and the path
+// is top-level `/moving`, never `/tasks/moving`: the manifest mounts `tasks` first and
+// its `/tasks/:id` would swallow a later literal segment (the `/inbox/awaiting-nod`
+// trap). The count and the handler live in ../moving.js so a test drives them with no
+// express and no database.
+//
+// MODULE BOUNDARY: reaches core only through the published doorway
+// `../../../src/module-api`; `../moving` is this module's own read.
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const moving = require('../moving');
+
+const log = api.logger('lifecycle');
+
+module.exports = function buildMovingRouter() {
+  const router = express.Router();
+
+  // rank: any-builder — GET /moving, the count behind Governing mode's "moving" tally.
+  // A count of rows every signed-in builder can already list on the Tasks board, so no
+  // floor above sign-in; nothing here is writable.
+  router.get('/moving', api.requireBuilder, moving.movingHandler({ log }));
+
+  return router;
+};

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.90",
+  "version": "1.21.91",
   "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

@@ -9370,5 +9370,11 @@
       "id": "1004655",
       "text": "Three government actions now have tests that check them the way the site really answers: choosing a form of government, taking back your own proposal before anyone votes, and seeing who each founding stage is still waiting on."
     }
+  ],
+  "1.21.91": [
+    {
+      "id": "1004563",
+      "text": "In Governing mode the top bar now shows two live numbers: how many things are waiting on the owner (\"needs you\") and how many tasks are being built or waiting to go live (\"moving\"). If a number can't be read it is simply left"
+    }
   ]
 }

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.90'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.91'; // 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/craft_mode_tallies.mjs

@@ -0,0 +1,149 @@
+// tests/craft_mode_tallies.mjs — Governing mode's header tallies (task 1004563, goal
+// 1000095 WA6): "needs you N · moving M" beside the eyebrow.
+//
+// Runs the REAL craft-mode.js over a small DOM with a stubbed fetch, and the REAL
+// server count (modules/lifecycle/moving.js) over a fake pool, so the two halves are
+// pinned where they actually decide: which statuses "moving" counts (owner decision
+// 2026-10-08: active + confirmed), and that a figure the page could not read is left
+// out rather than drawn as a zero that says nothing waits on you.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const CRAFT = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/craft-mode.js'), 'utf8');
+const require = createRequire(import.meta.url);
+process.env.NODE_ENV = 'test';
+const { countMoving, movingHandler, MOVING_STATUSES } = require('../modules/lifecycle/moving.js');
+
+function node(tag, id, cls) {
+  const attrs = {};
+  return {
+    tagName: tag, id: id || '', className: cls || '', dataset: {}, children: [], parentNode: null,
+    textContent: '', innerHTML: '',
+    setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; },
+    removeAttribute(k) { delete attrs[k]; },
+    get nextSibling() { const sib = this.parentNode && this.parentNode.children; return sib ? sib[sib.indexOf(this) + 1] || null : null; },
+    appendChild(c) { c.parentNode = this; this.children.push(c); return c; },
+    insertBefore(c, ref) {
+      c.parentNode = this;
+      const at = ref ? this.children.indexOf(ref) : -1;
+      if (at === -1) this.children.push(c); else this.children.splice(at, 0, c);
+      return c;
+    },
+    removeChild(c) { this.children.splice(this.children.indexOf(c), 1); c.parentNode = null; return c; },
+    querySelector(sel) { return all(this).find((n) => sel === '.' + n.className) || null; },
+    querySelectorAll() { return []; },
+    addEventListener() {}, classList: { toggle() {} },
+  };
+}
+function all(root) { return root.children.flatMap((c) => [c, ...all(c)]); }
+
+// answers: path → JSON body, or a number (an HTTP failure status), or 'throw'.
+function boot(mode, answers) {
+  const sidebar = node('NAV', 'app-sidebar');
+  sidebar.appendChild(node('DIV', '', 'app-sidebar__brand'));
+  const topbar = node('DIV', 'app-topbar');
+  topbar.appendChild(node('H2', 'topbar-title'));
+  const root = node('HTML');
+  const asked = [];
+  const document = {
+    documentElement: root, body: node('BODY'), activeElement: null,
+    getElementById: (id) => [sidebar, topbar, ...all(sidebar), ...all(topbar)].find((n) => n.id === id) || null,
+    querySelectorAll: () => [],
+    createElement: (t) => node(t.toUpperCase()),
+    addEventListener() {}, removeEventListener() {}, dispatchEvent() { return true; },
+  };
+  const mk = (obj) => ({ getItem: (k) => (k in obj ? obj[k] : null), setItem: (k, v) => { obj[k] = String(v); }, removeItem: (k) => { delete obj[k]; } });
+  const window = { localStorage: mk({}), sessionStorage: mk(mode ? { 'hall-craft': mode } : {}), matchMedia: () => ({ matches: false }) };
+  const fetch = (url) => {
+    asked.push(url);
+    const key = Object.keys(answers || {}).find((k) => url.endsWith(k));
+    const a = key ? answers[key] : 404;
+    if (a === 'throw') return Promise.reject(new Error('offline'));
+    if (typeof a === 'number') return Promise.resolve({ ok: false, status: a, json: () => Promise.resolve({}) });
+    return Promise.resolve({ ok: true, status: 200, json: () => Promise.resolve(a) });
+  };
+  const sandbox = { window, document, fetch, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
+  vm.createContext(sandbox);
+  vm.runInContext(CRAFT, sandbox, { filename: 'craft-mode.js' });
+  const craft = window.OTBCraftMode;
+  craft.mount();
+  const box = () => all(topbar).find((n) => n.id === 'craft-tallies') || null;
+  return { craft, topbar, asked, box };
+}
+const settle = () => new Promise((r) => setImmediate(r));
+const text = (html) => html.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+
+const BOTH = { '/blockers?limit=1': { blockers: [{ id: 1 }], page: { limit: 1, offset: 0, total: 3 } }, '/moving': { moving: 12, active: 9, confirmed: 3 } };
+
+test('Governing reads both counts and draws "needs you 3 · moving 12" right after the eyebrow', async () => {
+  const { topbar, box, asked } = boot('governing', BOTH);
+  await settle();
+  const b = box();
+  assert.ok(b, 'the tallies are drawn');
+  const eyebrow = all(topbar).find((n) => n.id === 'craft-eyebrow');
+  assert.equal(eyebrow.nextSibling, b, 'they sit directly after the mode words');
+  assert.equal(b.getAttribute('hidden'), null);
+  assert.equal(text(b.innerHTML), 'needs you 3 · moving 12');
+  assert.match(b.innerHTML, /craft-tally craft-tally--due/, 'something waits, so needs-you carries the warm dot');
+  assert.deepEqual(asked.map((u) => u.replace('/api/bongos', '')).sort(), ['/blockers?limit=1', '/moving'], 'one page of one blocker for the total, one count — never a task list');
+});
+
+test('nothing waiting draws "needs you 0" without the dot', async () => {
+  const { box } = boot('governing', { ...BOTH, '/blockers?limit=1': { blockers: [], page: { limit: 1, offset: 0, total: 0 } } });
+  await settle();
+  assert.equal(text(box().innerHTML), 'needs you 0 · moving 12');
+  assert.doesNotMatch(box().innerHTML, /craft-tally--due/);
+});
+
+test('a count that cannot be read is LEFT OUT, never drawn as zero', async () => {
+  const noMoving = boot('governing', { ...BOTH, '/moving': 401 });
+  await settle();
+  assert.equal(text(noMoving.box().innerHTML), 'needs you 3', 'a signed-out or failed /moving drops only its own figure');
+
+  const offline = boot('governing', { '/blockers?limit=1': 'throw', '/moving': { moving: 'lots' } });
+  await settle();
+  assert.equal(offline.box().getAttribute('hidden'), '', 'nothing readable: the slot stays hidden, no zeros');
+  assert.equal(offline.box().innerHTML, '');
+});
+
+test('only Governing wears the tallies, and leaving it removes them', async () => {
+  for (const mode of ['building', 'artistry', 'ideating', null]) {
+    const { box, asked } = boot(mode, BOTH);
+    await settle();
+    assert.equal(box(), null, `${mode || 'no mode'} draws no tallies`);
+    assert.deepEqual(asked, [], `${mode || 'no mode'} asks the server for nothing`);
+  }
+  const { craft, box } = boot('governing', BOTH);
+  await settle();
+  assert.ok(box());
+  craft.choose('building');
+  assert.equal(box(), null, 'switching away takes them down');
+});
+
+test('the server counts active + confirmed only, and sums them', async () => {
+  assert.deepEqual([...MOVING_STATUSES], ['active', 'confirmed']);
+  let seen;
+  const pool = { query: async (sql, params) => { seen = { sql, params }; return { rows: [{ status: 'active', n: 9 }, { status: 'confirmed', n: '3' }] }; } };
+  assert.deepEqual(await countMoving({ pool }), { moving: 12, active: 9, confirmed: 3 });
+  assert.deepEqual(seen.params, [['active', 'confirmed']]);
+  assert.match(seen.sql, /count\(\*\)/, 'a count in SQL, never rows to count in JS');
+  const empty = { query: async () => ({ rows: [] }) };
+  assert.deepEqual(await countMoving({ pool: empty }), { moving: 0, active: 0, confirmed: 0 }, 'a quiet board is a real zero');
+});
+
+test('GET /moving answers the count, and a failed read is a 500, not a zero', async () => {
+  const res = () => { const r = { headers: {} }; r.set = (k, v) => { r.headers[k] = v; }; r.json = (b) => { r.body = b; }; r.fail = (code, o) => { r.failed = { code, status: o.status }; }; return r; };
+  const ok = res();
+  await movingHandler({ count: async () => ({ moving: 4, active: 1, confirmed: 3 }) })({}, ok);
+  assert.deepEqual(ok.body, { moving: 4, active: 1, confirmed: 3 });
+  const bad = res();
+  await movingHandler({ count: async () => { throw new Error('db down'); }, log: { error() {} } })({}, bad);
+  assert.deepEqual(bad.failed, { code: 'moving_failed', status: 500 });
+  assert.equal(bad.body, undefined);
+});