@bongos/core 1.21.34 → 1.21.36

package/tests/governor_matter_acts.mjs

@@ -0,0 +1,241 @@
+// tests/governor_matter_acts.mjs — a PASSED matter at Automation, Release,
+// Review or Treasury carries out its act (task 1004561, goal 1000125), the way
+// People already did: after the close commits, through the owning module's act,
+// which calls the same function as that building's direct route. Also the two
+// new desks' server halves (the Treasury budget rows, the Review undo rows) and
+// the budget route's permission pin. DB-free: every write is a stub.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+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 GOV = path.join(ROOT, 'modules', 'government');
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const board = require(path.join(GOV, 'board.js'));
+const decisionBoard = require(path.join(GOV, 'decision-board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const autoActs = require(path.join(ROOT, 'modules', 'autonomy', 'matter-acts.js'));
+const autoDb = require(path.join(ROOT, 'modules', 'autonomy', 'db.js'));
+const lifeActs = require(path.join(ROOT, 'modules', 'lifecycle', 'matter-acts.js'));
+const lifeDb = require(path.join(ROOT, 'modules', 'lifecycle', 'db.js'));
+const doneWhen = require(path.join(ROOT, 'modules', 'lifecycle', 'done-when.js'));
+const doneWhenRoutes = require(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'done-when.js'));
+const gateRoutes = require(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'gate-approvals.js'));
+const lifeDocket = require(path.join(ROOT, 'modules', 'lifecycle', 'governor-docket.js'));
+const buildersRoute = require(path.join(ROOT, 'src', 'bongos', 'routes', 'builders.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+
+async function stub(obj, stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = obj[k]; obj[k] = v; }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) obj[k] = v; }
+}
+const sittingRow = (area, decided_by, rule) => ({ area, decided_by, rule, who: null, set_by_item_id: '30' });
+
+// Register every owning module's acts once, as their routers do at boot.
+autoActs.contributeAutomationMatterActs();
+lifeActs.contributeLifecycleMatterActs();
+buildersRoute();
+
+// ── the shape of each act ───────────────────────────────────────────────────
+
+test('each building\'s act is checked strictly when the matter is opened: shape, fields, nothing guessed', () => {
+  const v = decisionBoard.validateMatterAction;
+  assert.deepEqual(v('automation', { type: 'switch_on' }), { ok: true, action: { type: 'switch_on' } });
+  assert.deepEqual(v('automation', { type: 'allow_goal', goal_id: '12' }).action, { type: 'allow_goal', goal_id: 12 });
+  assert.deepEqual(v('release', { type: 'approve_gate', pr: 1500 }).action, { type: 'approve_gate', pr: 1500 });
+  assert.deepEqual(v('release', { type: 'approve_override', request_id: 4 }).action, { type: 'approve_override', request_id: 4 });
+  assert.deepEqual(v('review', { type: 'satisfy_criterion', criterion_id: 9 }).action, { type: 'satisfy_criterion', criterion_id: 9 });
+  assert.deepEqual(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: 50 }).action, { type: 'set_budget', builder_id: 7, monthly_usd: 50 });
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: null }).action.monthly_usd, null, 'null clears the limit');
+  // refusals, each named
+  assert.equal(v('rules', { type: 'switch_on' }).reason, 'action_not_supported_here');
+  assert.equal(v('planning', { type: 'switch_on' }).reason, 'action_not_supported_here');
+  assert.equal(v('automation', { type: 'satisfy_criterion', criterion_id: 9 }).reason, 'bad_action', 'an act from another building');
+  assert.equal(v('automation', { type: 'switch_on', goal_id: 3 }).reason, 'unknown_field');
+  assert.equal(v('automation', { type: 'allow_goal' }).field, 'action.goal_id');
+  assert.equal(v('automation', { type: 'allow_goal', goal_id: 0 }).reason, 'bad_action');
+  assert.equal(v('automation', { type: 'allow_goal', goal_id: true }).reason, 'bad_action');
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: -1 }).reason, 'bad_action');
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: '50' }).reason, 'bad_action');
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: 1e9 }).reason, 'bad_action');
+  assert.equal(v('review', []).reason, 'bad_action');
+  // People is unchanged
+  assert.deepEqual(v('people', { type: 'assign_rank', builder_id: '7', rank_key: 'tester' }).action, { type: 'assign_rank', builder_id: 7, rank_key: 'tester' });
+});
+
+test('every act in the table is carried out by its owning module, and only those', () => {
+  for (const [area, acts] of Object.entries(decisionBoard.MATTER_ACTIONS)) {
+    if (area === 'people') continue; // People acts inside the government module itself
+    for (const type of Object.keys(acts)) assert.ok(decisionBoard.matterActFor(area, type), `${area}.${type} has an act`);
+  }
+  assert.equal(decisionBoard.matterActFor('automation', 'satisfy_criterion'), null);
+});
+
+test('opening a matter whose act no module carries out is refused before anything is filed', async () => {
+  const never = async () => { throw new Error('must not be reached'); };
+  await stub(db, { listDecisionRules: async () => [sittingRow('automation', 'rank:council', 'majority')], createMatter: never, openBoardItem: never }, async () => {
+    await stub(api, { contributions: () => [] }, async () => {
+      const out = await board.openMatter({ area: 'automation', title: 'Switch it on', action: { type: 'switch_on' }, proposedBy: '42' });
+      assert.equal(out.reason, 'action_not_wired');
+    });
+  });
+  let made = null;
+  await stub(db, {
+    listDecisionRules: async () => [sittingRow('treasury', 'rank:council', 'majority')],
+    createMatter: async (a) => { made = a; return { id: '8', ...a }; },
+    openBoardItem: async (a) => ({ id: '40', subject_type: a.subjectType, subject_id: a.subjectId }),
+  }, async () => {
+    const out = await board.openMatter({ area: 'treasury', title: 'Ana: $50 a month', action: { type: 'set_budget', builder_id: 7, monthly_usd: 50 }, proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+  });
+  assert.deepEqual(made.action, { type: 'set_budget', builder_id: 7, monthly_usd: 50 });
+});
+
+// ── a passed matter acts; a returned one never does ─────────────────────────
+
+async function closeMatter({ area, action, outcome = 'passed', extraDb = {} }) {
+  const subjectType = `${area}_matter`;
+  const votes = outcome === 'passed' ? [{ voter_id: '9', direction: 'yes' }] : [{ voter_id: '9', direction: 'no', reason_md: 'no' }];
+  const events = [];
+  return stub(api, { emitAsync: async (name, payload) => { events.push([name, payload]); } }, () => stub(db, {
+    getVotesForItem: async () => votes,
+    closeBoardItem: async ({ outcome: o, afterClose }) => {
+      assert.equal(afterClose, null, 'a matter books nothing inside the close');
+      return { id: '40', subject_type: subjectType, subject_id: '8', opened_by: '42', closed_at: 'T', outcome: o };
+    },
+    getMatter: async () => ({ id: '8', area, title: 'A matter', action, proposed_by: '42' }),
+    insertAuthorRatifyKarma: async () => { throw new Error('a matter pays nobody'); },
+    getBoardItemAuthor: async () => '42',
+    ...extraDb,
+  }, async () => {
+    const item = { id: '40', subject_type: subjectType, subject_id: '8', opened_by: '42', closed_at: null, constitution: { membership: 'rank:council', pass_rule: 'first_ratifier', rule: 'first' } };
+    return { out: await board.closeItem(item), events };
+  }));
+}
+
+test('a passed Automation matter switches the fence and allows a goal, as the proposer, through the route\'s own writes', async () => {
+  const writes = [];
+  await stub(autoDb, {
+    setFenceEnabled: async (a) => { writes.push(['fence', a]); return { enabled: a.enabled }; },
+    allowGoal: async (a) => { writes.push(['allow', a]); return { goal_id: a.goalId }; },
+  }, async () => {
+    const on = await closeMatter({ area: 'automation', action: { type: 'switch_on' } });
+    assert.equal(on.out.outcome, 'passed');
+    assert.deepEqual(on.out.acted, { area: 'automation', matter_id: '8', action: 'switch_on', done: true });
+    const passed = on.events.find(([n]) => n === 'board.matter.passed');
+    assert.equal(passed[1].acted, true);
+    await closeMatter({ area: 'automation', action: { type: 'switch_off' } });
+    await closeMatter({ area: 'automation', action: { type: 'allow_goal', goal_id: 12 } });
+  });
+  assert.deepEqual(writes.map(([k, a]) => [k, a.enabled ?? a.goalId, a.builderId]), [['fence', true, '42'], ['fence', false, '42'], ['allow', 12, '42']]);
+  assert.match(writes[0][1].reason, /passed Automation matter \(matter 8\)/);
+});
+
+test('a RETURNED matter carries out nothing', async () => {
+  let wrote = false;
+  await stub(autoDb, { setFenceEnabled: async () => { wrote = true; return {}; } }, async () => {
+    const back = await closeMatter({ area: 'automation', action: { type: 'switch_on' }, outcome: 'returned' });
+    assert.equal(back.out.outcome, 'returned');
+    assert.equal(back.out.acted, undefined);
+  });
+  assert.equal(wrote, false);
+});
+
+test('a passed Review matter signs the criterion off by override, once', async () => {
+  const signed = [];
+  await stub(doneWhenRoutes, { satisfyByOverride: async (a) => { signed.push(a); return { updated: {}, goalResult: {} }; } }, () =>
+    stub(doneWhen, { getCriterion: async (id) => ({ id, satisfied: id === 10 }) }, async () => {
+      const out = (await closeMatter({ area: 'review', action: { type: 'satisfy_criterion', criterion_id: 9 } })).out;
+      assert.equal(out.acted.done, true);
+      const again = (await closeMatter({ area: 'review', action: { type: 'satisfy_criterion', criterion_id: 10 } })).out;
+      assert.deepEqual([again.outcome, again.acted.done, again.acted.reason], ['passed', false, 'already_satisfied'], 'a refusal leaves the decision standing');
+    }));
+  assert.equal(signed.length, 1);
+  assert.equal(signed[0].criterionId, 9);
+  assert.equal(signed[0].signerId, '42');
+  assert.match(signed[0].reason, /passed Review matter/);
+});
+
+test('a passed Release matter approves an override or clears a gate; a request already decided is said, not thrown', async () => {
+  const calls = [];
+  await stub(lifeDb, {
+    decideOverrideRequest: async (a) => {
+      calls.push(['override', a]);
+      if (a.requestId === 5) throw Object.assign(new Error('closed'), { code: 'REQUEST_NOT_OPEN' });
+      return {};
+    },
+  }, () => stub(gateRoutes, { approveGatePr: async (a) => { calls.push(['gate', a]); return a.number === 2 ? { ok: false, code: 'pr_not_open' } : { ok: true, body: {} }; } }, async () => {
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_override', request_id: 4 } })).out.acted.done, true);
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_override', request_id: 5 } })).out.acted.reason, 'request_not_open');
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_gate', pr: 1500 } })).out.acted.done, true);
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_gate', pr: 2 } })).out.acted.reason, 'pr_not_open');
+  }));
+  assert.deepEqual(calls[0], ['override', { requestId: 4, archonId: '42', decision: 'approve', note: 'A passed Release matter (matter 8) decided it.' }]);
+  assert.equal(calls[2][1].number, 1500);
+});
+
+test('a passed Treasury matter sets the limit through the same write as PATCH /builders/:id/budget', async () => {
+  const set = [];
+  const reward = seams.resolveOptional('reward');
+  const fake = { setBuilderMonthlyBudget: async (id, usd) => { set.push([id, usd]); return id === 404 ? null : { id, monthly_budget_usd: usd }; } };
+  await stub(seams, { resolveOptional: (name, fb) => (name === 'reward' ? fake : (reward && fb)) }, async () => {
+    assert.equal((await closeMatter({ area: 'treasury', action: { type: 'set_budget', builder_id: 7, monthly_usd: 50 } })).out.acted.done, true);
+    assert.equal((await closeMatter({ area: 'treasury', action: { type: 'set_budget', builder_id: 404, monthly_usd: null } })).out.acted.reason, 'builder_not_found');
+  });
+  assert.deepEqual(set, [[7, 50], [404, null]]);
+});
+
+test('an act that throws leaves the decision passed and says it did not run', async () => {
+  await stub(autoDb, { setFenceEnabled: async () => { throw new Error('db down'); } }, async () => {
+    const { out, events } = await closeMatter({ area: 'automation', action: { type: 'switch_on' } });
+    assert.equal(out.outcome, 'passed');
+    assert.deepEqual([out.acted.done, out.acted.reason], [false, 'act_failed']);
+    assert.equal(events.find(([n]) => n === 'board.matter.passed')[1].acted, false);
+  });
+});
+
+test('a stored act that no longer validates is not carried out', async () => {
+  let wrote = false;
+  await stub(autoDb, { allowGoal: async () => { wrote = true; } }, async () => {
+    const { out } = await closeMatter({ area: 'automation', action: { type: 'allow_goal', goal_id: -3 } });
+    assert.deepEqual([out.acted.done, out.acted.reason], [false, 'bad_action']);
+  });
+  assert.equal(wrote, false);
+});
+
+// ── the two desks' server halves ────────────────────────────────────────────
+
+test('Treasury desk: a row per builder, their limit as the fact, the other limits one tap each', () => {
+  const rows = buildersRoute.budgetDeskRows([{ id: 7, display_name: 'Ana', github_login: 'ana', monthly_budget_usd: '100.00' }, { id: 8, github_login: 'kai', monthly_budget_usd: null }]);
+  assert.equal(rows[0].fact, '$100 a month');
+  assert.deepEqual(rows[0].acts[0].options.map((o) => o.key), ['25', '50', '250', 'none']);
+  assert.ok(rows[0].acts[0].options.every((o) => o.label.length <= 16), 'every chip fits the line rule');
+  assert.equal(rows[1].fact, 'no limit');
+  assert.deepEqual(rows[1].acts[0].options.map((o) => o.key), ['25', '50', '100', '250']);
+  assert.deepEqual(rows[0].ref, { type: 'builder_budget', id: 7 });
+});
+
+test('Review desk: only signed-off promises, newest first, each undone with a one-tap reason', () => {
+  const rows = lifeDocket.signedDeskRows([
+    { id: 1, criterion_md: 'Old', satisfied: true, checked_at: '2026-09-01T00:00:00Z' },
+    { id: 2, criterion_md: 'New', satisfied: true, checked_at: '2026-10-02T00:00:00Z' },
+    { id: 3, criterion_md: 'Open', satisfied: false, checked_at: null },
+  ]);
+  assert.deepEqual(rows.map((r) => r.name), ['New', 'Old']);
+  assert.equal(rows[0].acts[0].key, 'unsign');
+  assert.ok(rows[0].acts[0].options.every((o) => o.label.length <= 16));
+});
+
+test('the desks are read under their routes\' own atoms, and the budget route is pinned', () => {
+  const desks = api.contributions('governor.docket').filter((c) => c && (c.desk === 'treasury.budgets' || c.desk === 'review.signed'));
+  const gates = Object.fromEntries(desks.map((c) => [c.desk, c.gate && c.gate.permission]));
+  assert.equal(gates['treasury.budgets'], 'builder.budget.set');
+  assert.equal(rrc.EXPECTED_RANKS['PATCH /builders/:id/budget'], 'perm:builder.budget.set');
+  const life = rrc.MODULE_EXPECTED_RANKS.lifecycle || Object.values(rrc.MODULE_EXPECTED_RANKS).find((m) => m['POST /done-when/:criterionId/unsatisfy']);
+  assert.equal(life['POST /done-when/:criterionId/unsatisfy'], 'perm:criterion.unsatisfy');
+});

package/tests/hall_matter_card.mjs

@@ -177,9 +177,18 @@ test('every act maps to the route that does it, with the body that route accepts
   assert.deepEqual(C.request(gate, 'release'), { method: 'POST', url: '/api/bongos/gate-approvals/812/approve', body: {} });
 });
 
-test('no act on any card reaches the core pin or a provisioning route', () => {
+// Task 1004559 moved the core update onto the Release desk, check first: the ONLY
+// way a card reaches the pin is the core_pin row, whose 'take' the server hands
+// only after a passed dry run (tests/hall_street_desk.mjs pins that), and which
+// needs the version chip as its confirmation. Nothing else may name the route.
+test('only the core_pin row reaches the core pin, and never without its version', () => {
   const src = read('street-card.js').replace(/^\s*\/\/.*$/gm, '');
-  assert.doesNotMatch(src, /core-upgrade|provisioning|\/core-update/);
+  const block = src.split('ACT_ROUTES.core_pin = {')[1].split('};')[0];
+  assert.equal(src.replace(block, '').match(/core-upgrade|provisioning|\/core-update/g), null, 'no other act names a provisioning route');
+  const cv = C.actsCard({ key: 'release.core:41', kind: 'core_pin', id: '41' });
+  assert.equal(C.request(cv, 'take', {}), null);
+  assert.equal(C.request(cv, 'check', {}), null);
+  assert.deepEqual(JSON.parse(JSON.stringify(C.request(cv, 'check', { option: '1.21.20' }))).body, { to: '1.21.20', dry_run: true });
 });
 
 test('an objection names its reason and its part before anything is sent; the parts are the server\'s own keys', () => {