@bongos/core 1.19.363 → 1.19.365

package/tests/government_board_summons.mjs

@@ -0,0 +1,222 @@
+// tests/government_board_summons.mjs — the summons: what is waiting on THIS
+// member's vote (task 1003271).
+//
+// THE BUG THIS PINS. Nine sittings sat open for two days with zero votes. The
+// board was never deadlocked — three of four archons could each have carried any
+// item with one click — they were simply never told, because the Discord
+// announcer was the only summons and it is best-effort by construction (an
+// unconfigured webhook, an unlinked member and a failed POST all end in a
+// swallowed log line). The durable summons is now the builder-needs roster.
+//
+// The rules pinned here:
+//   1. THE COUNT MATCHES WHAT THE VOTE ROUTE WOULD ACCEPT — a member, not the
+//      author, not already cast. Anything the route would refuse must not be
+//      counted, or the roster promises a ballot the route then denies.
+//   2. THE AUTHOR IS EXCLUDED, and that is the whole live symptom: the owner
+//      authored all nine, so their own count is zero while a peer's is nine.
+//   3. MEMBERSHIP IS PER-ITEM, off the item's OWN snapshotted constitution —
+//      never the live config — and resolved ONCE PER DISTINCT PREDICATE.
+//   4. FAIL-CLOSED AND FAIL-OPEN IN THE RIGHT DIRECTIONS: an unreadable
+//      predicate summons nobody; a DB error yields a zero count, never a throw
+//      (this runs on the /me session hot path and must not break a profile).
+//
+// DB-free (db monkeypatched — the sibling board tests' idiom).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+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 board = require(path.join(GOV, 'board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const needs = require(path.join(ROOT, 'modules', 'builder-settings', 'builder-needs.js'));
+
+async function withDb(stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = db[k]; db[k] = v; }
+  try { return await fn(); }
+  finally { for (const [k, v] of Object.entries(originals)) db[k] = v; }
+}
+
+const ARCHON = { membership: 'rank:archon', pass_rule: 'first_ratifier' };
+
+// One open item. author_id/already_voted are what the SQL hands back.
+const item = (id, { author = null, voted = false, constitution = ARCHON } = {}) => ({
+  id: String(id),
+  subject_type: 'full_idea',
+  subject_id: String(1000000 + Number(id)),
+  constitution,
+  opened_at: `2026-08-2${(Number(id) % 9) + 1}T00:00:00Z`,
+  closes_at: null,
+  author_id: author == null ? null : String(author),
+  already_voted: voted,
+});
+
+// ── rule 2: the live symptom — author sees nothing, a peer sees all nine ─────
+
+test('the author of every open item is summoned to none of them', async () => {
+  // The exact live shape: 9 items, all authored by builder 1000025, membership
+  // rank:archon, and 1000025 IS an archon. The vote route would refuse each one
+  // (anti_self_vote), so the roster must not claim any are waiting on them.
+  const items = Array.from({ length: 9 }, (_, i) => item(i + 1, { author: 1000025 }));
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => items,
+    builderHoldsRankActive: async () => true, // they really are an archon
+  }, async () => {
+    const out = await board.pendingVotesFor(1000025);
+    assert.equal(out.count, 0, 'the author must be summoned to zero of their own sittings');
+    assert.equal(out.first_item_id, null);
+  });
+});
+
+test('a peer archon who authored none of them is summoned to all nine', async () => {
+  const items = Array.from({ length: 9 }, (_, i) => item(i + 1, { author: 1000025 }));
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => items,
+    builderHoldsRankActive: async () => true,
+  }, async () => {
+    const out = await board.pendingVotesFor(1000094); // scootermack, not the author
+    assert.equal(out.count, 9);
+    // Oldest first — the sitting that has waited longest is the one to answer.
+    assert.equal(out.first_item_id, '1');
+  });
+});
+
+// ── rule 1: the count matches what the route would accept ────────────────────
+
+test('an already-cast vote is not counted again', async () => {
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => [
+      item(1, { author: 7, voted: true }),
+      item(2, { author: 7, voted: false }),
+    ],
+    builderHoldsRankActive: async () => true,
+  }, async () => {
+    const out = await board.pendingVotesFor(1);
+    assert.equal(out.count, 1, 'one vote each — a cast item is settled for this voter');
+    assert.equal(out.first_item_id, '2');
+  });
+});
+
+test('a non-member is summoned to nothing, however many items are open', async () => {
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => [item(1, { author: 7 }), item(2, { author: 7 })],
+    builderHoldsRankActive: async () => false, // not an archon
+  }, async () => {
+    const out = await board.pendingVotesFor(999);
+    assert.equal(out.count, 0);
+  });
+});
+
+test('an item with no author at all stays votable (nobody to disqualify)', async () => {
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => [item(1, { author: null })],
+    builderHoldsRankActive: async () => true,
+  }, async () => {
+    assert.equal((await board.pendingVotesFor(1000025)).count, 1);
+  });
+});
+
+// ── rule 3: membership is per-item, and resolved once per predicate ──────────
+
+test('membership comes from the ITEM snapshot, not one global answer', async () => {
+  // Two items under DIFFERENT constitutions: this builder sits on one board only.
+  const metic = { membership: 'rank:metic+', pass_rule: 'first_ratifier' };
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => [
+      item(1, { author: 7, constitution: ARCHON }),
+      item(2, { author: 7, constitution: metic }),
+    ],
+    builderHoldsRankActive: async (_id, rankKeys) => rankKeys.includes('metic'),
+  }, async () => {
+    const out = await board.pendingVotesFor(1000027);
+    assert.equal(out.count, 1, 'only the sitting whose snapshot enfranchises them');
+    assert.equal(out.first_item_id, '2');
+  });
+});
+
+test('one membership resolve per DISTINCT predicate, not one per item', async () => {
+  let calls = 0;
+  const items = Array.from({ length: 9 }, (_, i) => item(i + 1, { author: 7 }));
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => items,
+    builderHoldsRankActive: async () => { calls++; return true; },
+  }, async () => {
+    const out = await board.pendingVotesFor(5);
+    assert.equal(out.count, 9);
+    assert.equal(calls, 1, 'nine items under one constitution cost ONE resolve');
+  });
+});
+
+// ── rule 4: the two failure directions ──────────────────────────────────────
+
+test('an unreadable membership predicate summons nobody (fail-closed)', async () => {
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => [
+      item(1, { author: 7, constitution: { membership: 'not a predicate' } }),
+    ],
+    // Would say yes if it were ever asked — the parse must refuse first.
+    builderHoldsRankActive: async () => true,
+  }, async () => {
+    assert.equal((await board.pendingVotesFor(1)).count, 0);
+  });
+});
+
+test('a DB error yields a zero count, never a throw (the /me hot path)', async () => {
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => { throw new Error('boom'); },
+  }, async () => {
+    const out = await board.pendingVotesFor(1);
+    assert.equal(out.count, 0);
+    assert.equal(out.first_item_id, null);
+  });
+});
+
+test('a missing builder id is answered without touching the database', async () => {
+  await withDb({
+    openBoardItemsAwaitingVoter: async () => { throw new Error('must not be called'); },
+  }, async () => {
+    for (const id of [null, undefined, '']) {
+      assert.equal((await board.pendingVotesFor(id)).count, 0);
+    }
+  });
+});
+
+// ── the need the count feeds ─────────────────────────────────────────────────
+
+test('zero pending votes produces NO need row', () => {
+  // An empty state is not an input the system needs from you — the sibling
+  // collab needs take the same line.
+  assert.equal(needs.boardVotesNeed({}), null);
+  assert.equal(needs.boardVotesNeed({ pendingBoardVotes: { count: 0 } }), null);
+  assert.equal(needs.boardVotesNeed({ pendingBoardVotes: null }), null);
+});
+
+test('pending votes are action_needed and deep-link the oldest sitting', () => {
+  const n = needs.boardVotesNeed({ pendingBoardVotes: { count: 9, first_item_id: '1' } });
+  assert.equal(n.id, 'board_votes');
+  assert.equal(n.state, 'action_needed');
+  assert.equal(n.action.href, '/government?item=1#board-room');
+  // The hash is the TAB (makeTabs owns it); the item is a query param.
+  assert.match(n.action.href, /#board-room$/);
+});
+
+test('a count with no item id still links the room', () => {
+  const n = needs.boardVotesNeed({ pendingBoardVotes: { count: 2 } });
+  assert.equal(n.action.href, '/government#board-room');
+});
+
+test('the need reaches computeNeeds as an action_needed item', () => {
+  const out = needs.computeNeeds({
+    rank: 'archon', ownKeySet: true,
+    pendingBoardVotes: { count: 3, first_item_id: '4' },
+  });
+  const row = out.items.find((i) => i.id === 'board_votes');
+  assert.ok(row, 'the registry must carry the new need');
+  assert.equal(out.has_action_needed, true);
+  // action_needed sorts first, so a renderer taking "the first one" gets it.
+  assert.equal(out.items[0].id, 'board_votes');
+});

package/tests/government_board_vote.mjs

@@ -132,15 +132,46 @@ test('the demotion between open and vote refuses the vote — live re-check, unc
   });
 });
 
-test('anti-self: the author cannot vote on their own item — number/string ids compare equal', async () => {
+test('an author MAY cast on their own item, earns no karma for it — number/string ids compare equal', async () => {
+  // Task 1003273 replaced the flat refusal: an author may vote, and may never
+  // decide alone (enforced by the close trigger and the tally, not by refusing
+  // the cast — see government_board_majority.mjs). The id-shape detail this test
+  // has always guarded still matters: Postgres hands back a NUMBER author id
+  // while the voter carries a STRING, and the self-cast comparison must see
+  // through that, or an author would silently be paid karma on their own item.
+  let karmaPaid = 0;
   await withDb({
     getBoardItemForVote: async () => openItem(),
     builderHoldsRankActive: async () => true,
-    getBoardItemAuthor: async () => 42, // Postgres hands back a number; the voter carries a string
-    insertBoardVote: async () => { throw new Error('must not be reached'); },
+    getBoardItemAuthor: async () => 42, // number, deliberately
+    insertBoardVote: async (args) => ({ id: '9', voter_id: args.voterId, direction: args.direction }),
+    insertVoteKarma: async () => { karmaPaid += 1; },
   }, async () => {
     const out = await castVote({ itemId: 11, voterId: '42', direction: 'yes' });
-    assert.deepEqual(out, { ok: false, reason: 'anti_self_vote' });
+    assert.equal(out.ok, true);
+    assert.equal(out.self_cast, true, '42 and "42" are the same author');
+    assert.equal(out.karma_delta, 0);
+    assert.equal(karmaPaid, 0, 'a self-cast writes no karma row');
+  });
+});
+
+test('a NON-author on the same item is paid the vote karma as before', async () => {
+  // The contrast, so the no-karma rule above cannot silently become "no karma
+  // for anyone" — which would quietly delete the incentive to read other
+  // people's ideas.
+  let karmaPaid = 0;
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    builderHoldsRankActive: async () => true,
+    getBoardItemAuthor: async () => 42,
+    insertBoardVote: async (args) => ({ id: '9', voter_id: args.voterId, direction: args.direction }),
+    insertVoteKarma: async () => { karmaPaid += 1; },
+  }, async () => {
+    const out = await castVote({ itemId: 11, voterId: '77', direction: 'yes' });
+    assert.equal(out.ok, true);
+    assert.equal(out.self_cast, false);
+    assert.equal(out.karma_delta, VOTE_KARMA_DELTA);
+    assert.equal(karmaPaid, 1);
   });
 });
 

package/tests/government_board_vote_ui.mjs

@@ -47,11 +47,26 @@ test('an objection needs the reason AND exactly one section; a yes sends neither
   assert.match(cast, /item_closed/, 'a cast that CLOSED the sitting says so (first_ratifier / full turnout)');
 });
 
-test('the author of a full_idea sees the anti-self note instead of a form — amendments do not', () => {
+test('the author of a full_idea gets a REAL ballot plus the limit in words (task 1003273)', () => {
+  // This test used to assert the opposite — that an author saw a note INSTEAD of
+  // a form. That was the shape of the live bug: every open item was the reader's
+  // own, so the room offered nine sittings and no way to vote on any of them. The
+  // owner's rule is now "may vote, may not decide alone", so the form must be
+  // there and the limit must be stated rather than enforced by a missing button.
   const form = CLIENT.slice(CLIENT.indexOf('function voteFormHtml'), CLIENT.indexOf('async function castVoteFromRoom'));
   assert.match(form, /subject_type === 'full_idea'[^]*author_id.*viewerId/,
-    'the grey-out is SUBJECT-TYPED, mirroring castVote\'s carve-out — an amendment proposer may vote (§7)');
-  assert.match(form, /does not vote on it/, 'the note says why, not just no');
+    'still SUBJECT-TYPED — an amendment proposer is not held to the author rule (§7)');
+  // The note is now additive: it rides ALONGSIDE the buttons, not in place of them.
+  assert.match(form, /ownNote/, 'the own-idea note is composed into the form');
+  assert.match(form, /can\u2019t be decided by your vote alone|decided by your vote alone/,
+    'the note states the real limit');
+  assert.match(form, /earns no karma/, 'and that a self-cast is unpaid');
+  // The single most important structural assertion: there is exactly ONE return
+  // of the ballot, so no branch can silently withhold it from the author again.
+  assert.equal((form.match(/data-vote="yes"/g) || []).length, 1,
+    'one ballot, reachable by author and peer alike');
+  assert.ok(!/return `<p class="gov-grid-note">This is your idea/.test(form),
+    'the old form-suppressing early return is gone, not merely bypassed');
   assert.match(form, /if \(mine\) return ''/, 'one vote per member — a cast voter gets no second form');
   assert.match(form, /if \(item\.closed_at\) return ''/, 'closed sittings take no votes');
 });

package/tests/government_config.mjs

@@ -265,7 +265,7 @@ test('a malformed constitution can never widen the franchise or lower the bar',
     { membership: '' },
     { membership: { rank: 'archon' } },
     { pass_rule: 'unanimous' },
-    { pass_rule: 'majority' },
+    { pass_rule: 'unanimous' },
     { pass_rule: null },
     { membership: 'rank:xenos; DROP TABLE government_ranks' },
   ];
@@ -325,7 +325,14 @@ test('the resolved constitution is frozen, like the rest of the config contract'
 });
 
 test('PASS_RULES is the closed set the rest of the goal codes against', () => {
-  assert.deepEqual([...PASS_RULES].sort(), ['consent', 'first_ratifier']);
+  // `majority` joined the set in task 1003273 (owner decision 2026-08-25). The
+  // set stays CLOSED and asserted whole on purpose: board.js branches on these
+  // strings, so a rule added to config without a tally to match would be a
+  // constitution a project could adopt and then never resolve.
+  assert.deepEqual([...PASS_RULES].sort(), ['consent', 'first_ratifier', 'majority']);
   assert.ok(Object.isFrozen(PASS_RULES));
   assert.ok(PASS_RULES.includes(BOARD_DEFAULTS.pass_rule), 'the default must be a member of the set');
+  // The fail-closed default is UNCHANGED by the addition — adding a stricter rule
+  // must not move what a malformed constitution falls back to.
+  assert.equal(BOARD_DEFAULTS.pass_rule, 'first_ratifier');
 });