@bongos/core 1.19.363 → 1.19.365

package/src/bongos/routes/me.js

@@ -105,7 +105,7 @@ module.exports = function buildMeRouter() {
       builder, activeClaims, estVsActual, unlocked, lockedWithProgress, streakInfo,
       recentGrades, builderAvg, onboardingRow, shipCount, recentKarma, karma30d, discordLink, boxConnected, cliAuthed,
       behaviorPrefs, geminiKeyRow, needsRebaseTasks, foundingBuilder, helpRequestCount,
-      taskRecommendationCount,
+      taskRecommendationCount, boardVotesPending,
     ] = await Promise.all([
       db.getBuilderById(req.builder.id),
       lc().getActiveClaimsForBuilder(req.builder.id),
@@ -192,6 +192,19 @@ module.exports = function buildMeRouter() {
           return await lifecycle.openTaskRecommendationsFor(req.builder.id);
         } catch (_) { return 0; }
       })(),
+      // task 1003271: open board sittings waiting on THIS builder's vote, via
+      // the `government` port — core imports no module (ADR 0093). Nine items
+      // once sat for two days with nobody told, because the Discord announcer
+      // (best-effort by construction) was the only summons; this is the durable
+      // one. Same fan-out slot and fail-open posture as the two collab reads
+      // above: a board read must never be able to break a profile.
+      (async () => {
+        try {
+          const government = seams.resolveOptional('government');
+          if (!government || !government.pendingBoardVotesFor) return null;
+          return await government.pendingBoardVotesFor(req.builder.id);
+        } catch (_) { return null; }
+      })(),
     ]);
     // V3.R84 (#302), criterion C3: the builder's month-to-date spend vs their
     // monthly budget. Surfaced here so the CLI (session-start ping) and the hall
@@ -333,6 +346,10 @@ module.exports = function buildMeRouter() {
         // module (ADR 0093); undefined when lifecycle is off, which the need reads
         // as "nothing asked".
         openHelpRequests: helpRequestCount,
+        // task 1003271: { count, first_item_id } of open board sittings awaiting
+        // this builder's vote; null when government is off, which the need reads
+        // as "nothing waiting".
+        pendingBoardVotes: boardVotesPending,
         // task 1003173 (C03, goal 1000075): open task recommendations waiting on
         // this builder, read through the same `lifecycle` port so core never
         // imports the module (ADR 0093).

package/src/module-api.js

@@ -1156,8 +1156,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.361 with no explicit bump. run 32886106098. (task 1002620)
 //   1.19.363 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.362 with no explicit bump. run 32889324497. (task 1002620)
+//   1.19.364 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.363 with no explicit bump. run 32890225073. (task 1002620)
+//   1.19.365 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.364 with no explicit bump. run 32893443215. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.363'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.365'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/discord_board_broadcast.mjs

@@ -79,6 +79,45 @@ test('missing port, empty board, and a Discord failure are named skips — NEVER
   assert.equal((await postBoardAnnouncement(null, { log: () => {} })).skipped, 'no_item');
 });
 
+test('an unconfigured board channel is its OWN named skip, not a generic failure (task 1003271)', async () => {
+  // WHY THIS DISTINCTION EARNS A TEST. Nine sittings went unannounced and the
+  // logs could not say whether the webhook was never configured (an operator
+  // action) or Discord had failed (weather). Both used to read 'post_failed'.
+  const deps = {
+    resolveMembers: async () => [member(1, 'a')],
+    getLinks: async () => new Map(),
+    hasWebhook: () => false,
+    log: () => {},
+  };
+  const out = await postBoardAnnouncement(payload(), deps);
+  assert.deepEqual({ posted: out.posted, skipped: out.skipped },
+    { posted: false, skipped: 'channel_not_configured' });
+
+  // Configured but failing is still the OTHER skip — the two never collapse.
+  const failed = await postBoardAnnouncement(payload(), {
+    ...deps, hasWebhook: () => true, post: async () => { throw new Error('discord down'); },
+  });
+  assert.equal(failed.skipped, 'post_failed');
+
+  // An INJECTED poster resolves no webhook URL, so a missing one must not stop
+  // it — otherwise every deps-injected caller would report a false skip.
+  let sent = null;
+  const injected = await postBoardAnnouncement(payload(), {
+    ...deps, hasWebhook: () => false, post: async (_c, text) => { sent = text; return { message_id: '5' }; },
+    recordMessage: async () => {},
+  });
+  assert.equal(injected.posted, true, 'an injected poster is never gated on webhook config');
+  assert.ok(sent && sent.includes('before the board'));
+});
+
+test('hasWebhook answers false for an unknown channel and for a configured-but-absent one', () => {
+  assert.equal(webhook.hasWebhook('definitely_not_a_channel'), false);
+  assert.ok(webhook.CHANNELS.has('board_room'), 'the board channel is a known key');
+  // Its truth here depends on the environment, so pin the TYPE, not the value —
+  // a boolean is the contract the caller branches on.
+  assert.equal(typeof webhook.hasWebhook('board_room'), 'boolean');
+});
+
 test('the emitter fires on FRESH opens only, and the listener is registered (source pins)', () => {
   const board = fs.readFileSync(path.join(ROOT, 'modules', 'government', 'board.js'), 'utf8');
   const open = board.slice(board.indexOf('async function openWindowForFullIdea'), board.indexOf('async function emitWindowOpened'));

package/tests/government_board_amendment.mjs

@@ -56,7 +56,7 @@ test('every field is required and every refusal is named — no silent correctio
     [{ ...CONSENT_90, extra: true }, 'unknown_field'],
     [{ ...CONSENT_90, membership: 'everyone' }, 'bad_membership'],
     [{ ...CONSENT_90, membership: undefined }, 'bad_membership'],
-    [{ ...CONSENT_90, pass_rule: 'majority' }, 'bad_pass_rule'],
+    [{ ...CONSENT_90, pass_rule: 'unanimous' }, 'bad_pass_rule'],
     [{ ...CONSENT_90, window_minutes: 0 }, 'bad_window_minutes'],
     [{ ...CONSENT_90, window_minutes: 1.5 }, 'bad_window_minutes'],
     [{ ...CONSENT_90, close_early_on_full_turnout: 'yes' }, 'bad_close_early'],
@@ -68,8 +68,14 @@ test('every field is required and every refusal is named — no silent correctio
   }
   // THE CONTRAST WITH THE SANITIZER, stated as an assertion: the sanitizer
   // silently corrects a bad pass_rule; the proposal validator refuses it.
-  assert.equal(config.sanitizeBoard({ ...CONSENT_90, pass_rule: 'majority' }).pass_rule, 'first_ratifier');
-  assert.equal(validateProposedConstitution({ ...CONSENT_90, pass_rule: 'majority' }).ok, false);
+  assert.equal(config.sanitizeBoard({ ...CONSENT_90, pass_rule: 'unanimous' }).pass_rule, 'first_ratifier');
+  assert.equal(validateProposedConstitution({ ...CONSENT_90, pass_rule: 'unanimous' }).ok, false);
+  // THE PERMISSIVE HALF, asserted on purpose (task 1003273): `majority` is a
+  // REAL rule now, so a proposal naming it must be ACCEPTED. This used to be
+  // this file's canonical invalid value — a later change that quietly dropped
+  // majority back out of PASS_RULES has to fail here, not pass silently.
+  assert.equal(validateProposedConstitution({ ...CONSENT_90, pass_rule: 'majority' }).ok, true);
+  assert.equal(config.sanitizeBoard({ ...CONSENT_90, pass_rule: 'majority' }).pass_rule, 'majority');
 });
 
 // ── propose: files the row and opens the window in the same breath ──────────
@@ -101,7 +107,7 @@ test('an invalid proposal files NOTHING — refused before any write', async ()
     openBoardItem: async () => { throw new Error('must not be reached'); },
     builderHoldsRankActive: async () => true,
   }, async () => {
-    assert.equal((await proposeAmendment({ proposal: { ...CONSENT_90, pass_rule: 'majority' }, proposedBy: '42' })).ok, false);
+    assert.equal((await proposeAmendment({ proposal: { ...CONSENT_90, pass_rule: 'unanimous' }, proposedBy: '42' })).ok, false);
     assert.equal((await proposeAmendment({ proposal: CONSENT_90, proposedBy: null })).reason, 'missing_proposer');
   });
 });
@@ -245,15 +251,38 @@ test('the monarchy act end to end: the sole Archon ratifies their OWN amendment
   }
 });
 
-test('anti-self STILL binds for a full_idea — the carve-out is subject-typed', async () => {
+test('the author rule is still SUBJECT-TYPED — but it now limits deciding, not casting (task 1003273)', async () => {
+  // The old assertion here was that an author's cast on a full_idea is REFUSED
+  // (`anti_self_vote`). The owner replaced that rule on 2026-08-25: an author may
+  // vote, and may never decide alone. What must still differ by subject type is
+  // WHO IS HELD TO IT — an amendment proposer is not (§7's monarchy act, proven
+  // in the test above), an idea's author is.
+  let karmaPaid = 0;
+  let inserted = null;
   await withDb({
     getBoardItemForVote: async () => amendmentItem({ subject_type: 'full_idea', subject_id: '7' }),
     builderHoldsRankActive: async () => true,
     getBoardItemAuthor: async () => '42',
-    insertBoardVote: async () => { throw new Error('must not be reached'); },
+    insertBoardVote: async (args) => { inserted = { id: '1', voter_id: args.voterId, direction: args.direction }; return inserted; },
+    insertVoteKarma: async () => { karmaPaid += 1; },
+    getVotesForItem: async () => (inserted ? [inserted] : []),
+    getActiveBuildersWithRank: async () => [{ builder_id: '42', github_login: 'a', display_name: 'A' }],
+    closeBoardItem: async () => { throw new Error('must not close on the author\'s own vote'); },
   }, async () => {
-    assert.deepEqual(await castVote({ itemId: 21, voterId: '42', direction: 'yes' }),
-      { ok: false, reason: 'anti_self_vote' });
+    // 1. The cast is ACCEPTED — this is the permissive half, and it is the half a
+    //    later "tightening" would silently undo.
+    const cast = await castVote({ itemId: 21, voterId: '42', direction: 'yes' });
+    assert.equal(cast.ok, true, `an author's cast on their own idea must land: ${JSON.stringify(cast)}`);
+    assert.equal(cast.self_cast, true);
+    // 2. It earns NO karma — a self-vote confers no advantage.
+    assert.equal(cast.karma_delta, 0);
+    assert.equal(karmaPaid, 0, 'no karma row is written for a self-cast');
+    // 3. And it does NOT end the sitting: under first_ratifier the trigger needs
+    //    a non-author vote, so the item stays open for a real second voice. The
+    //    closeBoardItem stub above throws if this is ever violated.
+    const still = await maybeCloseAfterVote(21);
+    assert.deepEqual({ closed: still.closed, reason: still.reason },
+      { closed: false, reason: 'window_still_open' });
   });
 });
 

package/tests/government_board_close.mjs

@@ -113,7 +113,12 @@ test('a pass pays the author (+3, idempotent downstream); a return pays nobody',
   await withDb({
     getVotesForItem: async () => [no('42')],
     closeBoardItem: async ({ itemId, outcome }) => ({ ...openItem(), id: String(itemId), closed_at: 't', outcome }),
-    getBoardItemAuthor: async () => { throw new Error('must not be reached — a return pays nobody'); },
+    // task 1003273: the author is now READ before the tally on a full_idea —
+    // their own 'no' must not be able to return their own idea — so this can no
+    // longer assert "never asked". What it still asserts is the thing the test is
+    // about: a return PAYS nobody. Someone who did not vote, so the tally is
+    // unaffected by the author rule.
+    getBoardItemAuthor: async () => '999',
     insertAuthorRatifyKarma: async () => { throw new Error('must not be reached'); },
   }, async () => {
     const out = await closeItem(openItem());
@@ -162,6 +167,10 @@ test('consent with turnout outstanding leaves the window open', async () => {
     getBoardItemForVote: async () => openItem({ constitution: CONSENT }),
     getVotesForItem: async () => [yes('1')],
     getActiveBuildersWithRank: async () => [member(1), member(2)], // 1 of 2 voted
+    // task 1003273: the trigger reads the author too (an author's cast never
+    // closes the sitting). '999' voted on nothing, so consent's turnout maths is
+    // exactly as it was.
+    getBoardItemAuthor: async () => '999',
     closeBoardItem: async () => { throw new Error('must not be reached'); },
   }, async () => {
     assert.deepEqual(await maybeCloseAfterVote(11), { closed: false, reason: 'window_still_open' });
@@ -223,7 +232,9 @@ test('a RETURNED item books nothing and emits nothing — only a pass pays or an
       assert.equal(afterClose, null, 'no in-tx hook on a return — nothing to book');
       return { ...openItem(), closed_at: 't', outcome };
     },
-    getBoardItemAuthor: async () => { throw new Error('must not be reached'); },
+    // Read (the author rule's input) but never PAID and never completeness-read —
+    // the two things this test is actually about. See the note on the return case.
+    getBoardItemAuthor: async () => '999',
     getIdeaCompleteness: async () => { throw new Error('must not be reached'); },
   }, async () => {
     const out = await closeItem(openItem());

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,
+  );
+});