@bongos/core 1.21.112 → 1.21.114

package/tests/craft_mode_tallies.mjs

@@ -1,11 +1,15 @@
 // tests/craft_mode_tallies.mjs — Governing mode's header tallies (task 1004563, goal
-// 1000095 WA6): "needs you N · moving M" beside the eyebrow.
+// 1000095 WA6): "to do N · moving M" beside the eyebrow, on the city and the
+// street only (task 1004701, owner ruling 2026-10-09).
 //
 // 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.
+// out rather than drawn as a zero that says nothing waits on you. Since the living
+// city (task 1004685) both figures are the city's own (gov-living.js countsOf over
+// gov-feeds.js), so the real gov-living.js and gov-feeds.js run beside it here;
+// tests/hall_gov_counts.mjs holds the tally equal to every other surface.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import fs from 'node:fs';
@@ -16,6 +20,8 @@ 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 LIVING = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/gov-living.js'), 'utf8');
+const FEEDS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/gov-feeds.js'), 'utf8');
 const require = createRequire(import.meta.url);
 process.env.NODE_ENV = 'test';
 const { countMoving, movingHandler, MOVING_STATUSES } = require('../modules/lifecycle/moving.js');
@@ -44,7 +50,8 @@ function node(tag, id, cls) {
 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) {
+// page: the body's data-page (the tally stands on the city and the street only)
+function boot(mode, answers, page = 'city') {
   const sidebar = node('NAV', 'app-sidebar');
   sidebar.appendChild(node('DIV', '', 'app-sidebar__brand'));
   const topbar = node('DIV', 'app-topbar');
@@ -52,7 +59,7 @@ function boot(mode, answers) {
   const root = node('HTML');
   const asked = [];
   const document = {
-    documentElement: root, body: node('BODY'), activeElement: null,
+    documentElement: root, body: (() => { const b = node('BODY'); if (page) b.setAttribute('data-page', page); return b; })(), activeElement: null,
     getElementById: (id) => [sidebar, topbar, ...all(sidebar), ...all(topbar)].find((n) => n.id === id) || null,
     querySelectorAll: () => [],
     createElement: (t) => node(t.toUpperCase()),
@@ -68,20 +75,34 @@ function boot(mode, answers) {
     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); } } };
+  window.fetch = fetch;
+  const sandbox = { window, document, fetch, Date, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
   vm.createContext(sandbox);
+  // the living city's one counter and one reader, as the city and the street carry them
+  // (task 1004685): the tally prints their numbers, read through gov-feeds.js
+  vm.runInContext(LIVING, sandbox, { filename: 'gov-living.js' });
+  vm.runInContext(FEEDS, sandbox, { filename: 'gov-feeds.js' });
   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 settle = async () => { for (let i = 0; i < 20; i++) await 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 } };
+// Since the living city (task 1004685) the tally prints the city's own counts:
+// gov-living.js countsOf over gov-feeds.js COUNT_FEEDS, and since task 1004716 those
+// stand on ONE server read, GET /government/counts. Here three matters on the
+// viewer, no agent at work, twelve moving.
+const COUNTS = { viewer: { id: '1' }, on_you: 3, on_others: 0, open: 3, agents_at_work: 0, moving: 12, routed: true, yours: ['b:1', 'b:2', 'b:3'], others: [] };
+const BOTH = {
+  '/government/counts': COUNTS,
+  '/me': { builder: { id: '1', github_login: 'builder-1', rank: 'archon' } },
+};
+const COUNT_PATHS = ['/government/counts', '/me'];
 
-test('Governing reads both counts and draws "needs you 3 · moving 12" right after the eyebrow', async () => {
+test('Governing reads the city\'s counts and draws "to do 3 · moving 12" right after the eyebrow', async () => {
   const { topbar, box, asked } = boot('governing', BOTH);
   await settle();
   const b = box();
@@ -89,24 +110,25 @@ test('Governing reads both counts and draws "needs you 3 · moving 12" right aft
   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.equal(text(b.innerHTML), 'to do 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');
+  assert.deepEqual(asked.map((u) => u.replace('/api/bongos', '')).sort(), COUNT_PATHS,
+    'one server count, once, beside the viewer the shell already reads — 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 } } });
+test('nothing waiting draws "to do 0" without the dot', async () => {
+  const { box } = boot('governing', { ...BOTH, '/government/counts': { ...COUNTS, on_you: 0, open: 0, yours: [] } });
   await settle();
-  assert.equal(text(box().innerHTML), 'needs you 0 · moving 12');
+  assert.equal(text(box().innerHTML), 'to do 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 });
+  const noMoving = boot('governing', { ...BOTH, '/government/counts': { ...COUNTS, moving: null } });
   await settle();
-  assert.equal(text(noMoving.box().innerHTML), 'needs you 3', 'a signed-out or failed /moving drops only its own figure');
+  assert.equal(text(noMoving.box().innerHTML), 'to do 3', 'a moving count the server could not read drops only its own figure');
 
-  const offline = boot('governing', { '/blockers?limit=1': 'throw', '/moving': { moving: 'lots' } });
+  const offline = boot('governing', { '/government/counts': 'throw' });
   await settle();
   assert.equal(offline.box().getAttribute('hidden'), '', 'nothing readable: the slot stays hidden, no zeros');
   assert.equal(offline.box().innerHTML, '');
@@ -126,6 +148,20 @@ test('only Governing wears the tallies, and leaving it removes them', async () =
   assert.equal(box(), null, 'switching away takes them down');
 });
 
+test('the top bar carries the tally on the city and the street only (owner ruling, task 1004701)', async () => {
+  for (const page of ['city', 'street']) {
+    const { box } = boot('governing', BOTH, page);
+    await settle();
+    assert.ok(box(), `${page} carries the tally`);
+  }
+  for (const page of ['my-agents', 'board', 'home', null]) {
+    const { box, asked } = boot('governing', BOTH, page);
+    await settle();
+    assert.equal(box(), null, `${page || 'a page with no name'} draws no tally`);
+    assert.deepEqual(asked, [], `${page || 'a page with no name'} asks the server for nothing`);
+  }
+});
+
 test('the server counts active + confirmed only, and sums them', async () => {
   assert.deepEqual([...MOVING_STATUSES], ['active', 'confirmed']);
   let seen;

package/tests/discord_approvals.mjs

@@ -72,6 +72,17 @@ await t('memberApprovalLine round-trips through parseApprovalMarker', () => {
   assert.deepEqual(ap.parseApprovalMarker(line), { kind: 'member', id: 99 });
 });
 
+// A vouched takeover (ADR 0333 D4) re-posts the request with the row's words now; it
+// must still lead with the SAME marker, or a 👍 on it would resolve nothing.
+await t('the refiled line carries the new words and round-trips to the same request', () => {
+  const line = bcast.memberApprovalLine({ id: 99, github_login: 'carol', display_name: 'Carol', note: 'the real me', refiled: true });
+  assert.deepEqual(ap.parseApprovalMarker(line), { kind: 'member', id: 99 });
+  assert.match(line, /Carol/);
+  assert.match(line, /the real me/);
+  assert.match(line, /replace the earlier line for #99/);
+  assert.doesNotMatch(bcast.memberApprovalLine({ id: 99, github_login: 'carol' }), /replace/, 'a first line says nothing about replacing');
+});
+
 // ---- recordApprovalReaction (orchestration via fakes) ----------------------
 const GOOD_ID = '123456789012345678';
 const archon = { id: 1, rank: 'archon', github_login: 'example-owner' };

package/tests/discord_channels.mjs

@@ -361,6 +361,26 @@ await t('the real config declares the board-room channel, visible to every build
   assert.ok(board.topic && board.topic.length > 0, 'board-room needs a topic');
 });
 
+// task 1002536: the AI-news feed is the ZERO-CODE form the owner chose at the
+// 2026-07-29 triage — an off-the-shelf RSS service posts into one channel, and
+// nothing on our host polls anything. The channel is the whole repo surface, so
+// pin it: builders-only by INHERITING the BUILDERS category (spelling `view`
+// out would repeat the category and drift), and a topic that names #ideas,
+// because pasting a link there is the article → idea path (the inbound handler
+// reads only typed text, never a forwarded post, so Forward files no link).
+await t('the real config declares ai-news, builders-only, pointing readers at #ideas', () => {
+  const cfg = ch.loadConfig();
+  const cat = cfg.categories.find((c) => (c.channels || []).some((x) => x.key === 'ai-news'));
+  assert.ok(cat, 'expected a channel keyed ai-news');
+  const news = cat.channels.find((x) => x.key === 'ai-news');
+  assert.equal(ch.slugify(news.name), 'ai-news', 'the name must slug to its key, or apply creates a duplicate');
+  assert.equal(cat.name, 'BUILDERS');
+  assert.equal(news.view, undefined, 'ai-news must inherit, not repeat, its category view');
+  assert.equal(cat.view, 'xenos', 'so every builder, and only builders, can read it');
+  assert.ok(news.topic && news.topic.length <= 1024, 'Discord refuses a topic over 1024 characters');
+  assert.match(news.topic, /#ideas/, 'the topic must say where an article becomes an idea');
+});
+
 await t('the real config plans cleanly against an empty guild and never deletes', () => {
   const cfg = ch.loadConfig();
   const { ops } = ch.planChannelReconcile({ categories: [], channels: [] }, cfg, CTX_BOT);

package/tests/fixtures/gov-seated.mjs

@@ -0,0 +1,64 @@
+// tests/fixtures/gov-seated.mjs — A SEATED GOVERNMENT, as test data for the
+// hall's living-city tests (task 1004717). The hub has seated no Lead and built
+// nothing, so the harness fixtures alone cannot show a Lead's floor, a build-out
+// going up or one waiting on its vote. This builds them in the exact shapes the
+// routes answer — GET /government/leads with five Leads appointed by People votes,
+// Review's Testers room standing, a floor going up at Release and an annex
+// waiting on its sitting at Treasury — and routes the docket to those seats by
+// the server's own rule (modules/government/routing.js). The hall never reads it.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const routing = require(path.join(ROOT, 'modules', 'government', 'routing.js'));
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', name + '.json'), 'utf8'));
+
+// five Leads (the fixture's viewer, 1000025, leads Planning)
+export const SEATED = Object.freeze([
+  { building: 'planning', lead: '1000025', since: '2026-09-12', scope: 'Goals, priorities, the order of work.' },
+  { building: 'release', lead: '1000027', since: '2026-09-05', scope: 'Release floors and the path to going live.' },
+  { building: 'review', lead: '1000095', since: '2026-09-20', scope: 'Who checks finished work, and how.' },
+  { building: 'treasury', lead: '1000094', since: '2026-09-28', scope: 'Pots and the reserve.' },
+  { building: 'people', lead: '1000070', since: '2026-10-02', scope: 'Who joins, and the ranks they hold.' },
+]);
+
+// GET /government/leads with them in office and the three build-outs on the record
+export function leadsRead() {
+  const r = fx('government__leads');
+  const roster = fx('builders__roster').builders;
+  const at = (k) => r.buildings.find((b) => b.building === k);
+  for (const l of SEATED) {
+    const p = roster.find((x) => String(x.id) === l.lead) || { id: l.lead };
+    at(l.building).lead = { id: 'L' + l.building, building: l.building, builder: { id: String(p.id), login: p.github_login || null, name: p.display_name || null }, charter: l.scope, since: l.since, appointed_by: { item_id: '1' } };
+    at(l.building).answers = { seat: 'lead:' + l.building, builder_ids: [String(p.id)], fell_to_owner: false };
+  }
+  at('review').structure = { standing: [{ id: 2, capsule: 'committee', name: 'Testers', line: 'Who checks finished work.', state: 'built', progress: 1 }], proposed: [] };
+  at('release').structure = { standing: [{ id: 1, capsule: 'floor', name: 'Staging floor', line: '', state: 'building', progress: 0.55, allowed: { path: 'at_once', why: 'Its holder builds it out at once.' } }], proposed: [] };
+  at('treasury').structure = { standing: [], proposed: [{ capsule: 'annex', name: 'Investments arm', line: 'A wing for the reserve.', docket_id: 'board:77', item_id: '77' }] };
+  return r;
+}
+
+// the annex's sitting, open on the docket: nobody has voted yet
+function sitting(seats) {
+  return {
+    id: 'board:77', source: 'board', building: 'treasury', rule: 'majority', state: 'moving', title: 'Add an annex to Treasury: Investments arm', short: 'an annex',
+    opened_at: '2026-10-08T10:00:00.000Z', deadline: null, tally: { for: 0, against: 0, open: seats }, ref: { type: 'board_item', id: '77' }, acts: [],
+  };
+}
+
+// GET /government/docket with the sitting, every matter routed to those seats
+export function docketRouted() {
+  const d = fx('government__docket');
+  d.matters.push(sitting(d.buildings.find((b) => b.key === 'charter').holders.length));
+  const read = leadsRead();
+  const seats = { leads: read.buildings.filter((b) => b.lead).map((b) => ({ building: b.building, builder_id: b.lead.builder.id })), owner: read.owner, holders: {} };
+  d.matters.forEach((m) => {
+    const { route, ...bare } = m;
+    m.route = routing.routeMatter(bare, d.viewer.id, seats, Date.parse(d.generated_at));
+  });
+  return d;
+}