@bongos/core 1.19.364 → 1.19.365

package/tests/government_board_majority.mjs

@@ -0,0 +1,276 @@
+// tests/government_board_majority.mjs — the `majority` pass rule, and the author
+// rule that replaced the flat anti-self refusal (task 1003273).
+//
+// TWO OWNER DECISIONS OF 2026-08-25, pinned here:
+//   A. This project decides by MAJORITY. Strictly more than half of the RESOLVED
+//      MEMBERSHIP must vote yes. Silence is NOT assent — an item that never
+//      reaches a majority RETURNS at expiry. That is the whole difference from
+//      `consent`, which config.js documents as letting an empty window pass
+//      unopposed.
+//   B. An author MAY vote on their own idea, and may NEVER DECIDE ALONE. The old
+//      rule refused the cast outright and produced a dead end: every open item was
+//      authored by the one member reading them, so the room showed nine sittings
+//      and no ballot.
+//
+// THE PERMISSIVE ANSWERS ARE ASSERTED AS DELIBERATELY AS THE RESTRICTIVE ONES.
+// modules/government/CLAUDE.md warns that a later well-meaning "tightening" must
+// fail a test by design — an author's cast landing, and majority being a legal
+// pass_rule, are exactly the two things such a change would quietly undo.
+//
+// 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 config = require(path.join(GOV, 'config.js'));
+
+const {
+  hasMajority, majorityDecided, tallyOutcome, shouldCloseAfterVote,
+  castVote, maybeCloseAfterVote, closeItem,
+} = board;
+
+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 MAJORITY = {
+  membership: 'rank:archon', pass_rule: 'majority',
+  window_minutes: 4320, close_early_on_full_turnout: true,
+};
+const FIRST = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+
+const yes = (v) => ({ voter_id: String(v), direction: 'yes' });
+const no = (v, section = 'fit') => ({ voter_id: String(v), direction: 'no', reason_md: 'r', section_key: section });
+const member = (id) => ({ builder_id: String(id), github_login: `m${id}`, display_name: `M${id}` });
+// The live board this project actually has: 4 active archons.
+const FOUR = [member(1000025), member(1000094), member(1000095), member(3)];
+
+const ideaItem = (over = {}) => ({
+  id: '11', subject_type: 'full_idea', subject_id: '7', opened_by: null,
+  constitution: MAJORITY, closed_at: null, outcome: null, expired: false, ...over,
+});
+
+// ── A. more than half, never half ───────────────────────────────────────────
+
+test('majority is STRICTLY more than half — a tie is not a majority', () => {
+  // The 4-archon board this project runs: 3 carries, 2 does not.
+  assert.equal(hasMajority(3, 4), true);
+  assert.equal(hasMajority(2, 4), false, 'two of four is a tie, not a majority');
+  // Odd boards, and the degenerate ones.
+  assert.equal(hasMajority(2, 3), true);
+  assert.equal(hasMajority(1, 3), false);
+  assert.equal(hasMajority(1, 1), true);
+  assert.equal(hasMajority(0, 0), false, 'an empty board carries nothing');
+  assert.equal(hasMajority(1, 0), false);
+  assert.equal(hasMajority(0, 4), false);
+});
+
+test('the denominator is the MEMBERSHIP, not the votes cast', () => {
+  // Two yes votes out of nine members is not a majority, however unanimous the
+  // turnout was. This is the rule that stops low turnout quietly passing things.
+  assert.equal(
+    tallyOutcome([yes(1), yes(2)], { constitution: MAJORITY, members: Array.from({ length: 9 }, (_, i) => member(i + 1)), authorId: '99' }),
+    'returned',
+  );
+  assert.equal(
+    tallyOutcome([yes(1), yes(2)], { constitution: MAJORITY, members: [member(1), member(2), member(3)], authorId: '99' }),
+    'passed',
+  );
+});
+
+// ── A. silence is not assent ────────────────────────────────────────────────
+
+test('a majority sitting with ZERO votes RETURNS — the opposite of the other two rules', () => {
+  // The single most important difference. Under first_ratifier/consent an unvoted
+  // item PASSES, which is why a clock is unsafe there: the expiry sweep would
+  // ratify things nobody read. Under majority the same expiry returns them.
+  assert.equal(tallyOutcome([], { constitution: MAJORITY, members: FOUR, authorId: '1000025' }), 'returned');
+  // The contrast, asserted in the same breath so the distinction cannot rot:
+  assert.equal(tallyOutcome([], { constitution: FIRST, members: FOUR, authorId: '1000025' }), 'passed');
+  assert.equal(tallyOutcome([], { constitution: { pass_rule: 'consent' }, members: FOUR, authorId: null }), 'passed');
+});
+
+test('a short-of-majority sitting returns even with no objection at all', () => {
+  // Nobody voted no; it simply never carried. Under the legacy rules this would
+  // have passed, since only a reasoned objection returns an item there.
+  assert.equal(tallyOutcome([yes(1000094)], { constitution: MAJORITY, members: FOUR, authorId: '1000025' }), 'returned');
+});
+
+// ── B. the author may vote, and may never decide alone ──────────────────────
+
+test('an author MAY cast on their own idea, and it is recorded', async () => {
+  let written = null;
+  await withDb({
+    getBoardItemForVote: async () => ideaItem(),
+    builderHoldsRankActive: async () => true,
+    getBoardItemAuthor: async () => '1000025',
+    insertBoardVote: async (args) => { written = args; return { id: '1', voter_id: args.voterId, direction: args.direction }; },
+    insertVoteKarma: async () => { throw new Error('a self-cast must not be paid karma'); },
+  }, async () => {
+    const out = await castVote({ itemId: 11, voterId: '1000025', direction: 'yes' });
+    assert.equal(out.ok, true, 'the cast the OLD rule refused must now land');
+    assert.equal(out.self_cast, true);
+    assert.equal(out.karma_delta, 0);
+    assert.ok(written, 'the vote is really written, not merely tolerated');
+  });
+});
+
+test('a majority made ONLY of the author cannot carry the item', () => {
+  // A one-member board where that member is the author: 1 of 1 IS a majority, and
+  // it still must not pass — this is the guard that survives any constitution.
+  assert.equal(
+    tallyOutcome([yes(1000025)], { constitution: MAJORITY, members: [member(1000025)], authorId: '1000025' }),
+    'returned',
+  );
+  // The same votes with the author being someone else DO carry it, so the
+  // assertion above is about authorship and not about arithmetic.
+  assert.equal(
+    tallyOutcome([yes(1000025)], { constitution: MAJORITY, members: [member(1000025)], authorId: '999' }),
+    'passed',
+  );
+});
+
+test("the author's yes COUNTS toward the majority — it just cannot be all of it", () => {
+  // 4 members, majority = 3. Author + 2 peers = 3 → carries.
+  assert.equal(
+    tallyOutcome([yes(1000025), yes(1000094), yes(1000095)], { constitution: MAJORITY, members: FOUR, authorId: '1000025' }),
+    'passed',
+  );
+  // The 3 peers without the author also carry it, obviously.
+  assert.equal(
+    tallyOutcome([yes(1000094), yes(1000095), yes(3)], { constitution: MAJORITY, members: FOUR, authorId: '1000025' }),
+    'passed',
+  );
+  // But author + 1 peer is only 2 of 4 — a tie, not a majority.
+  assert.equal(
+    tallyOutcome([yes(1000025), yes(1000094)], { constitution: MAJORITY, members: FOUR, authorId: '1000025' }),
+    'returned',
+  );
+});
+
+test('an author cannot make their own idea WORSE by voting on it', () => {
+  // Their 'no' is excluded from the objection test, under every rule. Otherwise
+  // the safest act available to an author would be silence, which is a strange
+  // incentive to build into a board.
+  assert.equal(tallyOutcome([no(1000025)], { constitution: FIRST, members: FOUR, authorId: '1000025' }), 'passed');
+  // A PEER's no returns it, which is the rule that must survive.
+  assert.equal(tallyOutcome([no(1000094)], { constitution: FIRST, members: FOUR, authorId: '1000025' }), 'returned');
+});
+
+// ── B. the close trigger needs a voice that is not the author's ─────────────
+
+test("an author's cast never ends the sitting, under any rule", () => {
+  for (const constitution of [FIRST, MAJORITY, { ...MAJORITY, pass_rule: 'consent' }]) {
+    assert.equal(
+      shouldCloseAfterVote({ constitution, votes: [yes(1000025)], members: FOUR, authorId: '1000025' }),
+      false,
+      `${constitution.pass_rule}: the author alone must not close it`,
+    );
+  }
+  // A single NON-author vote closes it under first_ratifier, as it always did.
+  assert.equal(
+    shouldCloseAfterVote({ constitution: FIRST, votes: [yes(1000094)], members: FOUR, authorId: '1000025' }),
+    true,
+  );
+});
+
+test('the whole live deadlock, end to end: the author votes, and the item stays open for a real voice', async () => {
+  // This is the nine-items situation with the new rule. The author can now put a
+  // position on the record — which the old rule denied them — and the sitting
+  // still waits for someone else, which is the point.
+  let votes = [];
+  await withDb({
+    getBoardItemForVote: async () => ideaItem(),
+    builderHoldsRankActive: async () => true,
+    getBoardItemAuthor: async () => '1000025',
+    insertBoardVote: async (a) => { const v = { id: String(votes.length + 1), voter_id: a.voterId, direction: a.direction }; votes.push(v); return v; },
+    insertVoteKarma: async () => {},
+    getVotesForItem: async () => votes,
+    getActiveBuildersWithRank: async () => FOUR,
+    closeBoardItem: async () => { throw new Error('must not close yet'); },
+  }, async () => {
+    await castVote({ itemId: 11, voterId: '1000025', direction: 'yes' });
+    assert.deepEqual(await maybeCloseAfterVote(11), { closed: false, reason: 'window_still_open' });
+    // A second archon joins: 2 of 4 is a tie, still not a majority.
+    await castVote({ itemId: 11, voterId: '1000094', direction: 'yes' });
+    assert.deepEqual(await maybeCloseAfterVote(11), { closed: false, reason: 'window_still_open' });
+  });
+});
+
+test('the third yes carries it, and the close pays the author', async () => {
+  const votes = [yes(1000025), yes(1000094), yes(1000095)];
+  let paid = null;
+  await withDb({
+    getVotesForItem: async () => votes,
+    getBoardItemAuthor: async () => '1000025',
+    getActiveBuildersWithRank: async () => FOUR,
+    getIdeaCompleteness: async () => 100,
+    closeBoardItem: async ({ outcome }) => ({ ...ideaItem(), closed_at: 'T', outcome }),
+    insertAuthorRatifyKarma: async (a) => { paid = a; return true; },
+  }, async () => {
+    const out = await closeItem(ideaItem(), { cause: 'vote' });
+    assert.equal(out.outcome, 'passed', '3 of 4, with two non-author voices');
+    assert.ok(paid, 'ratification pays the author, as it always did');
+  });
+});
+
+// ── the early close: a sitting whose answer is fixed ────────────────────────
+
+test('a decided majority closes early rather than idling', () => {
+  // Carried already (3 of 4, with peers among them) — no later vote can change it.
+  assert.equal(majorityDecided({ votes: [yes(1000094), yes(1000095), yes(3)], members: FOUR, authorId: '1000025' }), true);
+  // Unreachable already: 3 of 4 voted no, so even a yes from the last member
+  // cannot reach 3. There is no vote-changing in v1, so this is final.
+  assert.equal(majorityDecided({ votes: [no(1000094), no(1000095), no(3)], members: FOUR, authorId: '1000025' }), true);
+  // Still live: 1 yes, 3 members yet to vote.
+  assert.equal(majorityDecided({ votes: [yes(1000094)], members: FOUR, authorId: '1000025' }), false);
+  // An empty board decides nothing.
+  assert.equal(majorityDecided({ votes: [], members: [], authorId: null }), false);
+});
+
+test('a majority that is only the author is NOT treated as decided', () => {
+  // It would be arithmetically carried on a 1-member board, but it cannot pass —
+  // so closing early would deny the item the one real voice that could save it.
+  assert.equal(majorityDecided({ votes: [yes(1000025)], members: [member(1000025)], authorId: '1000025' }), false);
+});
+
+test('full turnout closes a majority sitting, and only when the constitution says so', () => {
+  const all = [yes(1000025), no(1000094), no(1000095), no(3)];
+  // Every member has voted; the outcome is already unreachable anyway.
+  assert.equal(shouldCloseAfterVote({ constitution: MAJORITY, votes: all, members: FOUR, authorId: '1000025' }), true);
+  // With close_early off, an undecided-but-full sitting waits for the clock.
+  const split = [yes(1000025), yes(1000094)]; // 2 of 2 members here
+  const two = [member(1000025), member(1000094)];
+  assert.equal(
+    shouldCloseAfterVote({ constitution: { ...MAJORITY, close_early_on_full_turnout: false }, votes: split, members: two, authorId: '1000025' }),
+    true, 'carried on the merits (2 of 2, one non-author), so it closes regardless',
+  );
+});
+
+// ── the rule is a real, proposable value ───────────────────────────────────
+
+test('majority is a LEGAL pass_rule everywhere a rule is read', () => {
+  assert.ok(config.PASS_RULES.includes('majority'));
+  // The sanitizer keeps it (it is not a typo to be corrected away)…
+  assert.equal(config.sanitizeBoard({ ...MAJORITY }).pass_rule, 'majority');
+  // …and the fail-closed fallback is unchanged for a value that IS a typo.
+  assert.equal(config.sanitizeBoard({ ...MAJORITY, pass_rule: 'majorty' }).pass_rule, 'first_ratifier');
+  assert.equal(board.validateProposedConstitution({ ...MAJORITY }).ok, true);
+});
+
+test('an unknown rule still closes NOTHING after a vote (fail-closed, unchanged)', () => {
+  assert.equal(
+    shouldCloseAfterVote({ constitution: { pass_rule: 'whatever' }, votes: [yes(1000094)], members: FOUR, authorId: '1000025' }),
+    false,
+  );
+});

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');
 });