@bongos/core 1.21.140 → 1.21.142

package/tests/government_tidy_up.mjs

@@ -0,0 +1,223 @@
+// tests/government_tidy_up.mjs — the government tidy-up after the goal 1000111
+// chain (task 1004724). One case per item that changed behaviour; DB-free (every
+// read is stubbed at the module seam it goes through).
+//
+//   1  the spend-cap refusals are plain sentences, sent as-is
+//   2  "no Lead to remove" says what to do next
+//   3  a setting a law already holds is named by its row name, not its key
+//   5  /settings shows the law locks its reads report (settings-law-locks.js)
+//   7  in every city column the taller building stands at the back
+//   8  the city plaque's words are in the body face in both modes
+//   9  the docket reads every open blocker, so its counts are complete
+//  10  the office offers "who should lead", filed as the appoint_lead People matter
+//  11  a habit already up for a vote reads "proposed" after a reload
+//  12  two appointments racing to one unseated building: a clean refusal
+//   4  the treasury's dry-pot ask shows once: the book's card steps aside for the desk row
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+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 HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const projectSettings = require(path.join(ROOT, 'src', 'bongos', 'project-settings.js'));
+const govDb = require(path.join(ROOT, 'modules', 'government', 'db.js'));
+const board = require(path.join(ROOT, 'modules', 'government', 'board.js'));
+const decisionBoard = require(path.join(ROOT, 'modules', 'government', 'decision-board.js'));
+const ideasBlockers = require(path.join(ROOT, 'modules', 'ideas', 'blockers.js'));
+const ideasDocket = require(path.join(ROOT, 'modules', 'ideas', 'governor-docket.js'));
+const City = require(path.join(HALL, 'city-draw.js'));
+const MyAgents = require(path.join(HALL, 'my-agents.js'));
+const Laws = require(path.join(HALL, 'settings-law-locks.js'));
+const Office = require(path.join(HALL, 'street-office.js'));
+
+async function withStubs(target, stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = target[k]; target[k] = v; }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) target[k] = v; }
+}
+
+test('1: every spend-cap refusal is a plain sentence, and the route sends it as-is', () => {
+  for (const raw of ['', 'lots', 0, -5, projectSettings.MAX_SPEND_CAP_USD + 1]) {
+    const { reason } = projectSettings.parseSpendCap(raw);
+    assert.ok(reason, 'refused: ' + raw);
+    assert.match(reason, /^[A-Z].*\.$/, 'a sentence: ' + reason);
+    assert.doesNotMatch(reason, /usd|\.\.|^empty$|out of range/i, 'no code words: ' + reason);
+  }
+  assert.equal(projectSettings.parseSpendCap(200).usd, 200);
+  const route = read('modules', 'lifecycle', 'routes', 'project-settings.js');
+  assert.match(route, /res\.fail\('bad_spend_cap', \{ status: 400, message: parsed\.reason \}\)/);
+  assert.doesNotMatch(route, /message: `usd: /);
+});
+
+test('2: removing a Lead from a building with none says what to do next', async () => {
+  await withStubs(govDb, {
+    listDecisionRules: async () => [], listLeads: async () => [],
+    createMatter: async () => { throw new Error('nothing is filed'); },
+    openBoardItem: async () => { throw new Error('nothing is opened'); },
+  }, async () => {
+    const out = await board.openMatter({ area: 'people', title: 'No Lead', action: { type: 'remove_lead', building: 'review' }, proposedBy: '42' });
+    assert.equal(out.reason, 'no_lead');
+    assert.match(out.what_this_means, /has no Lead to remove/);
+    assert.match(out.what_this_means, /propose a Lead/, 'the next step is named');
+  });
+});
+
+test('3: a setting a law already holds is named by its row name in the toast', () => {
+  const src = read('modules', 'hall-ui', 'public', 'my-agents.js');
+  assert.match(src, /nameFor\(str\(err\.details\.setting\)\)/);
+  assert.doesNotMatch(src, /already holds ' \+ str\(err\.details/, 'never the raw key');
+  assert.equal(MyAgents.SETTING.verbosity.name, 'Reply length');
+});
+
+test('5: a law lock on /settings disables what it rules out and names the law', () => {
+  const data = { law_locks: [
+    { setting: 'verbosity', value: 'concise', law_no: 2, law_text: 'Agents keep replies short', enforced: true, allowed: ['concise'] },
+    { setting: 'wandering', max: 'focused', law_no: 3, law_text: 'Agents stay on task', enforced: true, allowed: ['locked', 'focused'] },
+    { setting: 'machinery', value: 'nonsense', law_no: 4, enforced: false, reason: 'value_not_allowed' },
+  ] };
+  const fixed = Laws.lockFor(data, 'verbosity');
+  assert.equal(Laws.allows(fixed, 'concise'), true);
+  assert.equal(Laws.allows(fixed, 'detailed'), false);
+  assert.equal(Laws.lawLine(fixed), 'Law 2 sets this for every agent in the project: "Agents keep replies short". Only a vote can change it.');
+  const cap = Laws.lockFor(data, 'wandering');
+  assert.deepEqual(['locked', 'focused', 'balanced', 'exploratory'].map((v) => Laws.allows(cap, v)), [true, true, false, false]);
+  assert.match(Laws.lawLine(cap), /^Law 3 caps this/);
+  assert.equal(Laws.tagFor(cap), 'set by law 3');
+  assert.equal(Laws.lockFor(data, 'machinery'), null, 'a lock that enforces nothing locks nothing');
+  assert.equal(Laws.lockFor({}, 'verbosity'), null);
+  assert.equal(Laws.allows(null, 'anything'), true);
+  // both panels read it, and the page loads it before either
+  assert.match(read('modules', 'hall-ui', 'public', 'settings-interaction.js'), /Laws\.lockFor\(data, f\.field\)/);
+  assert.match(read('modules', 'hall-ui', 'public', 'settings.js'), /Laws\.lockFor\(data, 'wandering'\)/);
+  const html = read('modules', 'hall-ui', 'public', 'settings.html');
+  const at = (s) => html.indexOf(s);
+  assert.ok(at('settings-law-locks.js') > 0 && at('settings-law-locks.js') < at('/builders/settings.js') && at('settings-law-locks.js') < at('settings-interaction.js'));
+});
+
+test('7: in every screen column of the civic quarter the taller building stands at the back', () => {
+  const at = City.CIVIC_SLOTS.map(([key, x, y]) => ({ key, col: x - y, depth: x + y, roof: City.ROOF[key] }));
+  for (const b of at) {
+    for (const o of at.filter((z) => z.col === b.col && z.depth > b.depth)) {
+      assert.ok(o.roof < b.roof, o.key + ' stands in front of the shorter ' + b.key);
+    }
+  }
+  assert.equal(new Set(City.CIVIC_SLOTS.map((s) => s[0])).size, 9, 'nine buildings');
+  assert.equal(new Set(City.CIVIC_SLOTS.map((s) => s[1] + ',' + s[2])).size, 9, 'nine lots');
+});
+
+test('8: the plaque words are in the body face (the light hall maps labels to mono)', () => {
+  const css = read('modules', 'hall-ui', 'public', 'city.css');
+  assert.match(css, /\.city-plaque__words \{ font-family: var\(--font-body\);/);
+});
+
+test('9: the docket reads every open blocker, so its counts are complete past 50', async () => {
+  const many = Array.from({ length: 120 }, (_, i) => ({ id: String(i + 1), title: 'Blocker ' + (i + 1), body_md: '', status: 'open', created_at: '2026-10-01T00:00:00.000Z', blocking_task_ids: [] }));
+  let asked = null;
+  seams._reset();
+  try {
+    await withStubs(ideasBlockers, { listOpenBlockers: async (o) => { asked = o; return many.slice(0, o && o.limit != null ? o.limit : many.length); } }, async () => {
+      ideasDocket.contributeIdeasToDocket();
+      const c = seams.contributions('governor.docket').find((x) => x.source === 'blockers');
+      const rows = await c.read({ has: () => true });
+      assert.equal(rows.length, 120, 'all of them');
+      assert.ok(asked.limit == null || asked.limit >= 1000, 'a ceiling far past any real list');
+    });
+  } finally { seams._reset(); }
+});
+
+test('10: the office offers who should lead to a builder who may open a board item, filed as appoint_lead', () => {
+  const living = { seats_real: true, owner: { name: 'Builder 1' }, buildings: [
+    { key: 'treasury', name: 'Treasury', lead: { id: '7', name: 'Gus', since: '2026-10-01' }, structure: null, construction: [], answers: { ids: ['7'] } },
+  ] };
+  const roster = { builders: [
+    { id: '9', display_name: 'Zoe', status: 'active' }, { id: '7', display_name: 'Gus', status: 'active' },
+    { id: '3', github_login: 'ann', status: 'active' }, { id: '4', display_name: 'Old', status: 'inactive' },
+  ] };
+  const may = { permissions: { 'board.item.open': true } };
+  assert.equal(Office.appointPlan(living, 'treasury', roster, { permissions: {} }), null, 'not offered without the perm');
+  assert.equal(Office.appointPlan(living, 'treasury', roster, null), null);
+  const plan = Office.appointPlan(living, 'treasury', roster, may);
+  assert.deepEqual(plan.people.map((p) => p.name), ['ann', 'Zoe'], 'active people, A to Z, never the Lead in office');
+  assert.equal(plan.seated, true);
+  const body = Office.appointBody(plan, '9');
+  assert.deepEqual(body, { area: 'people', title: 'Appoint Zoe as Lead of Treasury', action: { type: 'appoint_lead', building: 'treasury', builder_id: 9 } });
+  assert.equal(decisionBoard.validateMatterAction('people', body.action).ok, true, 'the server\'s own shape');
+  assert.equal(Office.appointBody(plan, '7'), null, 'only someone on the list');
+  assert.equal(Office.appointPlan(living, 'treasury', roster, may, { leadFiled: { treasury: true } }).filed, true);
+});
+
+test('11: a habit already up for a vote reads proposed after a reload', () => {
+  const room = { open: [
+    { id: '55', subject_type: 'constitutional_amendment', subject: { kind: 'laws', proposed: { enact: [{ text: 'Agents reply in detail', locks: [{ setting: 'verbosity', value: 'detailed' }] }] } } },
+    { id: '56', subject_type: 'constitutional_amendment', subject: { kind: 'board', proposed: { enact: [{ locks: [{ setting: 'machinery', value: 'quiet' }] }] } } },
+  ] };
+  const pending = MyAgents.pendingLaws(room);
+  assert.deepEqual(pending, { 'verbosity=detailed': '55' }, 'only laws sittings');
+  assert.deepEqual(MyAgents.pendingLaws(null), {});
+  assert.deepEqual(MyAgents.pendingLaws(false), {}, 'a 403 reads as none');
+  const me = {
+    builder: { id: '1' }, permissions: { 'board.item.open': true },
+    interaction: { fields: [{ field: 'verbosity', default_value: 'concise' }, { field: 'machinery', default_value: 'show' }], stored: { verbosity: 'detailed', machinery: 'quiet' }, effective: {} },
+  };
+  const v = MyAgents.buildView({ me, pending, proposed: {} }, {});
+  const h = (k) => v.habits.find((x) => x.key === k);
+  assert.equal(h('verbosity').proposed, true);
+  assert.equal(h('verbosity').item, '55');
+  assert.equal(h('machinery').proposed, false);
+  // a vote for ANOTHER value of the same setting is not this habit
+  const other = MyAgents.buildView({ me, pending: { 'verbosity=concise': '57' }, proposed: {} }, {});
+  assert.equal(other.habits.find((x) => x.key === 'verbosity').proposed, false);
+});
+
+test('12: two appointments racing to an unseated building end in a clean refusal, not a DB error', async () => {
+  const fake = (insertError) => ({
+    query: async (sql) => {
+      if (/^\s*INSERT INTO government_leads/.test(sql)) throw insertError;
+      if (/^\s*SELECT/.test(sql)) return { rows: [] };
+      return { rows: [] };
+    },
+    release: () => {},
+  });
+  const unique = Object.assign(new Error('duplicate key value violates unique constraint "government_leads_in_office_uniq"'), { code: '23505', constraint: 'government_leads_in_office_uniq' });
+  await withStubs(api.pool, { connect: async () => fake(unique) }, async () => {
+    const out = await govDb.applyLeadAct({ itemId: '40', action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'x' } });
+    assert.equal(out.done, false);
+    assert.equal(out.reason, 'lead_seated_meanwhile');
+    assert.doesNotMatch(out.what_this_means, /duplicate|constraint|23505/);
+  });
+  const other = Object.assign(new Error('boom'), { code: '23503' });
+  await withStubs(api.pool, { connect: async () => fake(other) }, async () => {
+    await assert.rejects(govDb.applyLeadAct({ itemId: '40', action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'x' } }), /boom/, 'any other failure still throws');
+  });
+});
+
+test('4: a book card steps aside when the floor desk below holds the same matter', () => {
+  const node = (attrs, kids = []) => {
+    const n = { attrs, kids, parentNode: null, getAttribute: (k) => (k in attrs ? attrs[k] : null) };
+    kids.forEach((k) => { k.parentNode = n; });
+    n.removeChild = (c) => { n.kids = n.kids.filter((x) => x !== c); c.parentNode = null; };
+    return n;
+  };
+  const all = (n) => n.kids.flatMap((k) => [k, ...all(k)]);
+  const card1 = node({ 'data-ask': 'treasury_spending:1' });
+  const card2 = node({ 'data-ask': 'blockers:9' });
+  const book = node({}, [card1, card2]);
+  const govt = node({}, [book]);
+  govt.querySelectorAll = (sel) => (sel === '[data-ask]' ? all(govt).filter((n) => n.attrs['data-ask']) : []);
+  const desk = node({}, [node({ 'data-row': 'treasury_spending:1' })]);
+  desk.querySelector = (sel) => { const m = /^\[data-row="(.*)"\]$/.exec(sel); return m ? all(desk).find((n) => n.attrs['data-row'] === m[1]) || null : null; };
+  assert.equal(Office.page.settle(govt, desk), 1);
+  assert.deepEqual(book.kids.map((k) => k.attrs['data-ask']), ['blockers:9'], 'the one the desk shows is gone; the other stays');
+  assert.equal(Office.page.settle(null, desk), 0);
+  // street.js settles the book after it fills the floor desk
+  assert.match(read('modules', 'hall-ui', 'public', 'street.js'), /fillDesk\(on, bv\); if \(OP && OP\.settle\) OP\.settle\(\$\('insideGovt'\), on\);/);
+});

package/tests/hall_goals_open_first.mjs

@@ -0,0 +1,120 @@
+// tests/hall_goals_open_first.mjs — the hall Home goals card leads with the OPEN
+// goals the builder has joined, with the claimable work in each (task 1004755).
+//
+// The owner's acceptance test of criterion wa6-noise-limited found the card
+// listing COMPLETED goals: it kept every non-archived goal, so achieved goals took
+// slots in the five-row cap. This boots the real goals.js in a vm against a fake
+// API and reads what it renders.
+//
+// Run:  node tests/hall_goals_open_first.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const { claimableCountsByGoal } = require('../modules/lifecycle/claimable-counts.js');
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/goals.js'), 'utf8');
+const { test, summary } = makeRunner();
+
+async function renderCard({ goals, members, claimable }) {
+  const body = { innerHTML: '' };
+  const host = { innerHTML: '', querySelector: () => body };
+  let widget = null;
+  const routes = (p) => {
+    if (p === '/api/bongos/me') return { builder: { id: 7 } };
+    if (p === '/api/bongos/goals') return { goals };
+    if (p === '/api/bongos/tasks/claimable?group=goal') {
+      return { by_goal: claimableCountsByGoal(claimable), claimable_total: claimable.length };
+    }
+    if (p.startsWith('/api/bongos/tasks/claimable')) throw new Error('the card must not download the claimable feed: ' + p);
+    const m = p.match(/^\/api\/bongos\/goals\/(\d+)$/);
+    if (m) {
+      const g = goals.find((x) => String(x.id) === m[1]);
+      return { goal: g, criteria: [], members: members[g.id] || [] };
+    }
+    return null;
+  };
+  const window = {
+    OTB: {
+      escapeHtml: (s) => String(s),
+      contributeHallWidget: (w) => { widget = w; },
+    },
+    BongosClient: {
+      createClient: () => ({
+        request: async (_m, p) => { const data = routes(p); return { status: data ? 200 : 404, ok: !!data, data }; },
+      }),
+    },
+    location: { assign() {} },
+  };
+  vm.runInNewContext(SRC, { window, console, Promise, Map, String, Array, Math, encodeURIComponent });
+  widget.mount(host);
+  for (let i = 0; i < 20; i++) await new Promise((r) => setImmediate(r));
+  return body.innerHTML;
+}
+
+const me = [{ builder_id: 7 }];
+
+await test('an achieved goal the builder joined is NOT listed; the open one is', async () => {
+  const html = await renderCard({
+    goals: [
+      { id: 1, title: 'Finished goal', status: 'achieved' },
+      { id: 2, title: 'Live goal', status: 'open' },
+    ],
+    members: { 1: me, 2: me },
+    claimable: [],
+  });
+  assert.ok(html.includes('Live goal'), 'the open joined goal is shown');
+  assert.ok(!html.includes('Finished goal'), 'the completed goal is left off the card');
+});
+
+await test('achieved goals no longer take the five slots ahead of open ones', async () => {
+  const goals = [];
+  for (let i = 1; i <= 5; i++) goals.push({ id: i, title: `Done ${i}`, status: 'achieved' });
+  goals.push({ id: 9, title: 'Open nine', status: 'open' });
+  const members = Object.fromEntries(goals.map((g) => [g.id, me]));
+  const html = await renderCard({ goals, members, claimable: [] });
+  assert.ok(html.includes('Open nine'));
+  assert.ok(!/Done \d/.test(html));
+});
+
+await test('each open goal carries how much claimable work sits in it', async () => {
+  const html = await renderCard({
+    goals: [{ id: 2, title: 'Live goal', status: 'open' }, { id: 3, title: 'Quiet goal', status: 'open' }],
+    members: { 2: me, 3: me },
+    claimable: [{ id: 10, goal_id: 2 }, { id: 11, goal_id: 2 }, { id: 12, goal_id: null }],
+  });
+  assert.match(html, /Live goal[\s\S]*2 tasks you can claim/);
+  assert.match(html, /Quiet goal[\s\S]*Nothing claimable right now/);
+});
+
+await test('a goal the builder has not joined is not listed', async () => {
+  const html = await renderCard({
+    goals: [{ id: 4, title: 'Someone else', status: 'open' }],
+    members: { 4: [{ builder_id: 99 }] },
+    claimable: [],
+  });
+  assert.ok(!html.includes('Someone else'));
+  assert.match(html, /joined any open goals/);
+});
+
+await test('claimableCountsByGoal counts per goal and skips goal-less rows', () => {
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(claimableCountsByGoal([{ goal_id: 2 }, { goal_id: '2' }, { goal_id: 5 }, { goal_id: null }, {}, null]))),
+    { 2: 2, 5: 1 });
+  assert.deepEqual(claimableCountsByGoal(undefined), {});
+});
+
+await test('the route answers ?group=goal with counts and no rows', () => {
+  const route = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/routes/tasks.js'), 'utf8');
+  const body = route.slice(route.indexOf("req.query.group === 'goal'"));
+  assert.ok(body.slice(0, 300).includes('res.json({ by_goal: claimableCountsByGoal(feed), claimable_total: feed.length })'));
+});
+
+summary();

package/tests/hall_studio_home.mjs

@@ -248,6 +248,23 @@ try {
     assert.equal(lib.askedLine(0), '');
   });
 
+  await test('Where your pages are (task 1004662): the server in-flight list, worded, stuck first, with how long', () => {
+    assert.deepEqual(lib.inFlightRows(PAGES, NOW).map((r) => [r.page_id, r.state, r.age, r.stuck]), [
+      ['landing:index', 'Being written', '', false],
+    ], 'the open round the ledger holds, no date on it so no age');
+    const rows = lib.inFlightRows({ in_flight: [
+      { page_id: 'landing:contact', title: 'Contact', surface: 'landing', state_word: 'Approved, going live', since: day(17), stuck: true },
+      { page_id: 'builders:work', title: 'Tasks', surface: 'builders', state_word: 'Submitted, waiting to be applied', since: day(1), stuck: false },
+      { page_id: 'status:index', title: 'Status', surface: 'status', state_word: null, since: NOW.toISOString(), stuck: true },
+    ] }, NOW);
+    assert.deepEqual(rows.map((r) => [r.title, r.state, r.age, r.stuck]), [
+      ['Contact', 'Approved, going live', 'for 17 days', true],
+      ['Tasks', 'Submitted, waiting to be applied', 'for 1 day', false],
+      ['Status', 'Needs a look', 'since today', true],
+    ]);
+    assert.deepEqual(lib.inFlightRows(null, NOW), []);
+  });
+
   await test('a word on the page finds its own line: the most specific wins, holes alone never match, shared never', () => {
     const sentence = 'Home, on the landing page, is where you left it. Twelve of its thirty-eight lines are yours so far.';
     assert.equal(lib.matchLine(sentence, STUDIO_READING.lines).key, 'L0003', 'not the generic "{…} of {…}"');
@@ -335,6 +352,9 @@ try {
     assert.match(body, /1 of 2 tweaked/);
     assert.match(body, /style="width: 50%"/);
     assert.match(body, /1 page has been asked for/);
+    assert.match(body, /Where your pages are/);
+    assert.match(body, /st-flight__state">Being written</, 'the open round shows where it is');
+    assert.match(body, /href="\/builders\/tweak-editor\?page=landing:index"/);
     await s.clickIn('st-panel', '[data-close-panel]');
     assert.equal(s.el('st-panel').hidden, true);
     assert.ok(!s.html.classList.contains('st-open'));