@bongos/core 1.19.364 → 1.19.366

package/scripts/gds/ship-io.js

@@ -14,8 +14,7 @@ const { playSound } = require('./ship-state.js');
 function playShipBell() {
   let shipWav = 'ship';
   try {
-    const prefsPath = require('path').join(os.homedir(), '.config', 'otb', 'sound-prefs.json');
-    const raw = require('fs').readFileSync(prefsPath, 'utf8');
+    const raw = require('fs').readFileSync(shipPrefsPath(), 'utf8');
     const parsed = JSON.parse(raw);
     const ev = parsed && parsed.event_sounds && parsed.event_sounds['task-shipped'];
     if (typeof ev === 'string') shipWav = ev;
@@ -23,6 +22,20 @@ function playShipBell() {
   playSound(shipWav);
 }
 
+// task 1003272: this used to hardcode ~/.config/otb/, the PRE-RENAME location,
+// while fetch-sound-prefs.js writes the mirror through
+// instance-config.configPath() — today ~/.config/cloudbongos/. Reader and writer
+// were looking at different files, so a builder's chosen ship sound was never
+// found and this always fell through to the 'ship' default. Resolve the SAME way
+// the writer does, with the legacy path as a fallback for an older box.
+function shipPrefsPath() {
+  try {
+    const p = require('../../src/instance-config').configPath('sound-prefs.json');
+    if (require('fs').existsSync(p)) return p;
+  } catch (_) { /* fall through to the legacy location */ }
+  return require('path').join(os.homedir(), '.config', 'otb', 'sound-prefs.json');
+}
+
 // task 1002809: normalize an API error body across BOTH wire shapes — the live
 // ADR 0116 (R01) envelope `{ error: { code, message } }` and the legacy flat
 // `{ error: 'code' }`. Same normalization as claim.js:formatClaimFailure and
@@ -93,6 +106,7 @@ function postLandShipOutcome({ code, liveStatus }) {
 // the early returns are control flow only.
 
 module.exports = {
+  shipPrefsPath,
   apiErrorLine,
   normalizeApiError,
   playShipBell,

package/scripts/gds/turn-end-sound.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// scripts/gds/turn-end-sound.js — the Stop hook that rings when a turn ends
+// (task 1003272).
+//
+// THE TRIGGER THAT NEVER EXISTED. scripts/gds/fetch-sound-prefs.js has always
+// described "a LOCAL Stop hook + ship.js via .claude/sounds/play.js", and
+// sound-prefs.js has always labelled `chime` as "When Claude finishes a turn" —
+// but .claude/settings.json had no Stop hook at all. So the single most
+// noticeable sound in the system had nothing to fire it, on top of the player
+// being absent and four of the five WAVs never having been committed. Three
+// independent gaps, one symptom: "all sound seems bugged".
+//
+// WHY A SCRIPT RATHER THAN AN INLINE HOOK COMMAND. The variant resolution below
+// is the same logic ship-io.js's playShipBell() already uses (read the mirrored
+// prefs, take the event's chosen wav, fall back to a base sound). That is a
+// couple of lines too many for a JSON string, and a hook that cannot be read is
+// a hook nobody will fix.
+//
+// IT MUST ALWAYS EXIT 0 AND FAST. This runs at the end of every turn. It resolves
+// a name, hands it to a fire-and-forget player that spawns detached, and returns;
+// every failure path is a silent no-op. A Stop hook that threw, or that blocked
+// on audio, would make a cosmetic feature everyone's problem.
+
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs');
+
+// `user-input` is the event whose meaning matches a turn ending — Claude has
+// paused and it is the builder's move. Falls back to `chime`, which is the base
+// sound sound-prefs.js labels "When Claude finishes a turn".
+const EVENT_ID = 'user-input';
+const FALLBACK_WAV = 'chime';
+
+// Resolve the mirror the SAME way fetch-sound-prefs.js writes it
+// (instance-config.configPath — today ~/.config/cloudbongos/), with the
+// pre-rename ~/.config/otb/ as a fallback for an older box. Hardcoding the
+// legacy path is the bug this task found in two other readers; it is not going
+// to be re-introduced here.
+function prefsPath() {
+  try {
+    const p = require('../../src/instance-config').configPath('sound-prefs.json');
+    if (fs.existsSync(p)) return p;
+  } catch (_) { /* fall through */ }
+  return path.join(os.homedir(), '.config', 'otb', 'sound-prefs.json');
+}
+
+function resolveWav() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(prefsPath(), 'utf8'));
+    const chosen = parsed && parsed.event_sounds && parsed.event_sounds[EVENT_ID];
+    if (typeof chosen === 'string' && chosen) return chosen;
+  } catch (_) { /* no mirror yet — the fallback is the honest default */ }
+  return FALLBACK_WAV;
+}
+
+function main() {
+  try {
+    // Guarded exactly like ship-state.js's: on a checkout without the player
+    // (or mid-re-seed) this is a no-op, never a failed turn.
+    let playSound;
+    try {
+      ({ playSound } = require(path.resolve(__dirname, '..', '..', '.claude', 'sounds', 'play.js')));
+    } catch (_) { return; }
+    if (typeof playSound === 'function') playSound(resolveWav());
+  } catch (_) { /* cosmetic, always */ }
+}
+
+if (require.main === module) {
+  main();
+  process.exit(0); // never let a stray handle hold the turn open
+}
+module.exports = { resolveWav, prefsPath, EVENT_ID, FALLBACK_WAV };

package/src/module-api.js

@@ -1158,8 +1158,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         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)
+//   1.19.366 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.365 with no explicit bump. run 32895705036. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.364'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.366'; // 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/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,
+  );
+});

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