@bongos/core 1.19.225 → 1.19.227

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.225",
-  "core_contract": "1.19.225",
-  "source_commit": "1f495d4acc6813ee9a5cb936244452e840b7fde3",
+  "core_version": "1.19.227",
+  "core_contract": "1.19.227",
+  "source_commit": "f6137a0375f70937656a4026edfe79fb32897774",
   "source_ref": "HEAD",
-  "built_at": "2026-08-18T04:37:38.138Z",
+  "built_at": "2026-08-18T04:58:06.044Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 311,
     "agent_docs_stubbed": 21,
-    "functional_verbatim": 1308,
+    "functional_verbatim": 1309,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1640,
-  "tree_sha256": "2b8fa57da152a118479d80755587e79a98aff9c540845309b0548b2b6573fadd",
+  "file_count": 1641,
+  "tree_sha256": "eede258e0c6a9ae77dd442500e39fdb81956608f764730d9eccbf7caa11a4fce",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -2902,7 +2902,7 @@
     {
       "path": "modules/government/board.js",
       "mode": "0000644",
-      "sha256": "0711f087cc61ed19f91fb207705a9e4831422c9acf29ae8402f87926a31d2a51"
+      "sha256": "43a284c7c69e3181268d1cb1e177deecbafe3c2693881211a74e72442aabf854"
     },
     {
       "path": "modules/government/catalog.js",
@@ -2917,7 +2917,7 @@
     {
       "path": "modules/government/db.js",
       "mode": "0000644",
-      "sha256": "1f50cef895c7937aebbb365aa7a9ce1b1681bd097034c0045d94458cd369f50a"
+      "sha256": "8bd28cbedd0dcb829147ad341c5a0bd3cf30225d6b2665c66218172a1930d1b0"
     },
     {
       "path": "modules/government/migrations/governance_001_tables.sql",
@@ -3007,7 +3007,7 @@
     {
       "path": "modules/government/routes/government.js",
       "mode": "0000644",
-      "sha256": "41ac023e96901b9b3cf8a5059a5c26ff5f86b564d7bb37dc8d5a55a206db85fb"
+      "sha256": "63ab50af4bc8d36db246eacfc9041c18cf0af89279f8ffe8e89f67978773401b"
     },
     {
       "path": "modules/government/routes/rank-sync.js",
@@ -3517,7 +3517,7 @@
     {
       "path": "modules/ideas/completeness.js",
       "mode": "0000644",
-      "sha256": "84d977372c79a46f8481176b7cdc740cbaca9480af3464b7b66183aad6d6e180"
+      "sha256": "07e5666362c91f92d34388b4f6f4507cc5387866d317970478e6cae417c19975"
     },
     {
       "path": "modules/ideas/inbox.js",
@@ -3547,7 +3547,7 @@
     {
       "path": "modules/ideas/routes/inbox.js",
       "mode": "0000644",
-      "sha256": "e6dd2d295186a081592009ae0b2341a477bdcc71c8b0cf10747f22a811f4683c"
+      "sha256": "9e9288725b66b696bdc565e693c82f046bd78665ae070e3f571ff987f82a7b7b"
     },
     {
       "path": "modules/ideas/templates.js",
@@ -4302,12 +4302,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "4dbb837e40ad8c1e5d1ee8085874c70f618899982e417ac8645234e072d3e04b"
+      "sha256": "9f7314822fed28bb1cc244c3a440c0139fa6c383f58019565647078c267738d8"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "02009e59987400a1715dd4a03a0ec172006a633fd106ab0b188fec705e5fc522"
+      "sha256": "2b3299463571782b859abbccdb9a2fb7d0130dc6390da6de5484ab6c9800bde3"
     },
     {
       "path": "public-docs/index.html",
@@ -5922,7 +5922,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "605f8e482d11f3e2c764a76109b3f63d4a4781630d03c44b7ebd3dd2077f389a"
+      "sha256": "206a9ffcb92d028f8f954dad04df2ec172bfacbd6be04d5204176acd4a94788a"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -6844,6 +6844,11 @@
       "mode": "0000644",
       "sha256": "8f5354cbacf15c9b49500f96b265fe52f5c0d4500a4ec7b41b4819a149782893"
     },
+    {
+      "path": "tests/government_board_close.mjs",
+      "mode": "0000644",
+      "sha256": "59b35a20d28c2d689fac976f02eb0e10e95ef887c63702b9e52e3361e71eb6b4"
+    },
     {
       "path": "tests/government_board_membership.mjs",
       "mode": "0000644",
@@ -7077,7 +7082,7 @@
     {
       "path": "tests/idea_completeness.mjs",
       "mode": "0000644",
-      "sha256": "e7b6af463185ea77f40d62408026c55c7fb077f18999b972564b3b5bc7656ca5"
+      "sha256": "7e2024b3f1fa79a6bdec55b134be6337d4867df0a77fedb205f32b783a3d6193"
     },
     {
       "path": "tests/idea_full_capture.mjs",

package/modules/government/board.js

@@ -42,7 +42,7 @@
 
 const db = require('./db');
 const { loadGovernmentConfig } = require('./config');
-const { isBoardMember } = require('./board-membership');
+const { isBoardMember, resolveBoardMembers } = require('./board-membership');
 
 // ADR 0175 §5: the completeness bar a Full Idea must clear to reach the board.
 // Held equal to economy's IDEA_FULL_PASS_BAR by test — see the header.
@@ -198,6 +198,86 @@ async function castVote({ itemId, voterId, direction, reasonMd = null, sectionKe
   return { ok: true, vote: inserted, fresh: true, karma_delta: VOTE_KARMA_DELTA };
 }
 
+// ── close + tally (BV1.R10 of goal 1000069, ADR 0175 §3) ────────────────────
+//
+// EVERY RULE DECLARED, NONE EMERGENT. The tally is one line: a single reasoned
+// objection returns the idea; anything else — including ZERO votes — passes.
+// Absent members are NULLED by construction rather than by branch: the tally
+// only ever reads the votes that were cast, so a member who never voted simply
+// does not exist in it, and absence can never block (§2 — the sitting model).
+// A zero-vote pass is safe because the idea already cleared the grade gate,
+// the author could not vote for themselves, and the ballot is open.
+//
+// TWO TRIGGERS, ONE CLOSE PATH:
+//   • after a vote — first_ratifier closes on the FIRST vote (monarchy: the
+//     Archon ratifies or returns, done); consent closes early only on FULL
+//     TURNOUT (every current member has voted — recorded positions and the
+//     vote karma are worth the wait, and no later vote can change the outcome
+//     anyway since there is no vote-changing in v1);
+//   • on expiry — R11's poller calls the same closeItem, so the clock and the
+//     turnout can never disagree about what a close means.
+// An unknown pass_rule closes NOTHING after a vote (fail-closed — only the
+// clock can end it), the same strict-end posture as R05's sanitizer.
+//
+// THE CLOSE IS STRUCTURALLY SINGLE-WINNER: closeBoardItem's UPDATE carries
+// WHERE closed_at IS NULL, so two concurrent closers (a racing vote and the
+// expiry sweep, say) write exactly one outcome and the loser reads it back.
+//
+// RATIFICATION PAYS THE AUTHOR HERE — this is what fires the +3
+// awardAuthorRatifyKarma R08 declared (idempotent by reason key, so a re-driven
+// close never double-pays). THE PASS EVENT IS DELIBERATELY NOT EMITTED HERE:
+// that is R12's contract (docs/specs/board-room-pass-event-contract.md), and
+// its once-per-idea semantics deserve their own slice — the sweep-friendly
+// `WHERE outcome = 'passed'` shape survives precisely because closing and
+// emitting are separate acts.
+
+// The whole counting rule. Absence is nulled by what this function DOESN'T
+// read: only cast votes exist here.
+function tallyOutcome(votes) {
+  return (votes || []).some((v) => v.direction === 'no') ? 'returned' : 'passed';
+}
+
+// Should a just-cast vote close the item now, under the SNAPSHOTTED rule?
+function shouldCloseAfterVote({ constitution, votes, members } = {}) {
+  const rule = (constitution || {}).pass_rule;
+  if (rule === 'first_ratifier') return (votes || []).length >= 1;
+  if (rule === 'consent') {
+    if (!(constitution || {}).close_early_on_full_turnout) return false;
+    if (!members || !members.length) return false; // an empty board has no turnout to complete
+    const voters = new Set((votes || []).map((v) => String(v.voter_id)));
+    return members.every((m) => voters.has(String(m.builder_id)));
+  }
+  return false; // unknown rule: only the clock closes it
+}
+
+// Close an item: tally what was cast, write the outcome, pay the author on a
+// pass. Idempotent end to end — the single-winner UPDATE plus the karma's
+// reason-key guard. `cause` is for the caller's telemetry ('vote' | 'expiry').
+async function closeItem(item, { cause = 'vote' } = {}) {
+  if (!item || item.closed_at) return { closed: false, reason: 'already_closed' };
+  const votes = await db.getVotesForItem(item.id);
+  const outcome = tallyOutcome(votes);
+  const closed = await db.closeBoardItem({ itemId: item.id, outcome });
+  if (!closed) return { closed: false, reason: 'already_closed' };
+  const authorKarma = outcome === 'passed' ? await awardAuthorRatifyKarma(closed) : null;
+  return { closed: true, item: closed, outcome, cause, author_karma: authorKarma };
+}
+
+// The post-vote hook R08's route fires after a FRESH cast. Reads everything it
+// judges — the item, the votes, the LIVE members under the snapshot's rule —
+// per request, uncached, then hands closeItem the decision.
+async function maybeCloseAfterVote(itemId) {
+  const item = await db.getBoardItemForVote(Number(itemId));
+  if (!item || item.closed_at) return { closed: false, reason: 'not_open' };
+  const constitution = item.constitution || {};
+  const votes = await db.getVotesForItem(item.id);
+  const members = await resolveBoardMembers(constitution);
+  if (!shouldCloseAfterVote({ constitution, votes, members })) {
+    return { closed: false, reason: 'window_still_open' };
+  }
+  return closeItem(item, { cause: 'vote' });
+}
+
 module.exports = {
   FULL_IDEA_PASS_BAR,
   ideaPassesBar,
@@ -208,4 +288,8 @@ module.exports = {
   awardAuthorRatifyKarma,
   validateVote,
   castVote,
+  tallyOutcome,
+  shouldCloseAfterVote,
+  closeItem,
+  maybeCloseAfterVote,
 };

package/modules/government/db.js

@@ -372,6 +372,31 @@ async function getBoardVote(itemId, voterId) {
 // so the idempotent re-cast can never double-pay. granted_by NULL: earned from
 // the system by the act, not granted by a person (the governance_002 backfill
 // convention). karma_log is a shared core table; same access rule as above.
+// Every vote cast on an item, in cast order — the tally's whole input. Absent
+// members are nulled by construction: they have no row here to read.
+async function getVotesForItem(itemId) {
+  const { rows } = await pool.query(
+    `SELECT * FROM government_board_votes WHERE item_id = $1 ORDER BY cast_at, id`,
+    [itemId],
+  );
+  return rows;
+}
+
+// The close write — STRUCTURALLY SINGLE-WINNER: WHERE closed_at IS NULL means
+// two concurrent closers (a racing vote and the expiry sweep) write exactly one
+// outcome; the loser gets null and reads the winner's row back if it cares.
+// closed_at comes from the database clock, like every timestamp on this table.
+async function closeBoardItem({ itemId, outcome }) {
+  const { rows } = await pool.query(
+    `UPDATE government_board_items
+        SET closed_at = now(), outcome = $2
+      WHERE id = $1 AND closed_at IS NULL
+      RETURNING *`,
+    [itemId, outcome],
+  );
+  return rows[0] || null;
+}
+
 // Author-ratification karma (+3, board.js AUTHOR_RATIFY_KARMA_DELTA) — fired by
 // the R10 close on a passed item. IDEMPOTENT: the reason key is unique per item
 // and the INSERT is one atomic WHERE-NOT-EXISTS statement (the economy
@@ -423,4 +448,6 @@ module.exports = {
   getBoardVote,
   insertVoteKarma,
   insertAuthorRatifyKarma,
+  getVotesForItem,
+  closeBoardItem,
 };

package/modules/government/routes/government.js

@@ -445,6 +445,19 @@ module.exports = function buildGovernmentRouter() {
           400; // bad_direction / yes_carries_nothing / objection_needs_reason / objection_needs_section
         return res.fail(out.reason, status, { item_id: itemId });
       }
+      // R10: a fresh cast may CLOSE the sitting — first_ratifier closes on the
+      // first vote (monarchy: the Archon ratifies or returns, done); consent
+      // closes early on full turnout. The close is single-winner in the schema,
+      // so a concurrent racer is safe, and a close hiccup never loses the vote
+      // (already recorded) — fail-open, the capture-path posture.
+      let closure = null;
+      if (out.fresh) {
+        try {
+          closure = await board.maybeCloseAfterVote(itemId);
+        } catch (closeErr) {
+          console.error('[gds] post-vote close failed (vote recorded, close left to the expiry sweep):', closeErr);
+        }
+      }
       // Idempotent re-cast reads back the standing vote — 200, not 201, and no
       // karma line: nothing new was recorded.
       res.status(out.fresh ? 201 : 200).json({
@@ -452,6 +465,7 @@ module.exports = function buildGovernmentRouter() {
         vote: out.vote,
         already_voted: !out.fresh,
         ...(out.fresh ? { karma_delta: out.karma_delta } : {}),
+        ...(closure && closure.closed ? { item_closed: true, outcome: closure.outcome } : {}),
       });
     } catch (err) {
       console.error('[gds] POST /government/board/items/:itemId/votes', err);

package/modules/ideas/completeness.js

@@ -69,4 +69,47 @@ function completenessScore(fieldValues, opts) {
   return scoreFieldValues(fieldValues, opts).score;
 }
 
-module.exports = { completenessScore, scoreFieldValues, substanceOf };
+// ── the sub-bar rejection payload (BV1.R09 of goal 1000069, ADR 0175 §4) ────
+//
+// Criterion C2's other half: an idea that never reaches the board (sub-bar,
+// ADR 0175 §5) still returns to its author WITH A REASON THEY CAN ACT ON. The
+// reason is computed, not written: the per-field breakdown above already knows
+// which section carried the least substance, so the weakest section is flagged
+// automatically — same shape as a board objection (reason_md + section_key,
+// government_003's vote payload), so R13's return flow renders one thing.
+//
+// DETERMINISTIC AND DERIVED, NEVER STORED: the scorer is deterministic, so the
+// flag is recomputable from field_values at any time — storing it would be a
+// second copy that drifts. Ties go to TEMPLATE ORDER (the fields array is
+// already in it), so the flag is stable for identical inputs.
+//
+// BAR-AGNOSTIC BY DESIGN: whether a score is sub-bar is decided where the bar
+// lives (economy's IDEA_FULL_PASS_BAR / the board's gate) — this constructs the
+// payload once a caller has decided. Passing an unscorable input returns null,
+// the same "cannot score" posture as everything above.
+
+function weakestField(fieldValues, opts) {
+  const { fields } = scoreFieldValues(fieldValues, opts);
+  if (!fields.length) return null;
+  return fields.reduce((worst, f) => (f.ratio < worst.ratio ? f : worst));
+}
+
+// The rejection payload for a sub-bar Full Idea: { section_key, reason_md } in
+// the board-objection shape. The reason names the section by its TEMPLATE LABEL
+// (the words the author saw when writing) and states the shortfall in the
+// scorer's own honest terms — substance against the floor, nothing smarter.
+function weakestSectionPayload(fieldValues, { templateKey = DEFAULT_TEMPLATE_KEY, registry = BUILTIN_TEMPLATES } = {}) {
+  const worst = weakestField(fieldValues, { templateKey, registry });
+  if (!worst) return null;
+  const template = templateFor(templateKey, registry);
+  const field = template.fields.find((f) => f.key === worst.key);
+  const label = field ? field.label : worst.key;
+  return {
+    section_key: worst.key,
+    reason_md: `Completeness is below the bar, and "${label}" is the thinnest section — `
+      + `${worst.substance} character${worst.substance === 1 ? '' : 's'} of substance against a floor of ${worst.floor}. `
+      + 'Flesh that section out and resubmit; the score is deterministic, so the same words always score the same.',
+  };
+}
+
+module.exports = { completenessScore, scoreFieldValues, substanceOf, weakestField, weakestSectionPayload };

package/modules/ideas/routes/inbox.js

@@ -7,7 +7,7 @@ const inbox = require('../inbox');
 // Full Idea capture (task 1002919 / BV1.R143): the template validator (R141)
 // and the deterministic scorer (R142) — both pure, both walk the declaration.
 const { validateFieldValues } = require('../templates');
-const { completenessScore } = require('../completeness');
+const { completenessScore, weakestSectionPayload } = require('../completeness');
 const { validateOrRespond, LIMITS, parseId } = api;
 
 const INBOX_STATUS_VALUES = ['open', 'promoted', 'discarded', 'merged'];
@@ -166,6 +166,17 @@ module.exports = function buildInboxRouter() {
               });
               if (w && w.opened && w.item) {
                 idea.board_window = { item_id: w.item.id, closes_at: w.item.closes_at };
+              } else if (w && w.reason === 'below_bar') {
+                // R09 (goal 1000069, criterion C2): a sub-bar idea returns to
+                // its author WITH A REASON THEY CAN ACT ON — the weakest section
+                // auto-flagged from the per-field scores, in the same shape as a
+                // board objection. Riding the BOARD'S OWN below_bar answer keeps
+                // the bar in exactly one place (board.js); this module never
+                // decides what "sub-bar" means. Derived, not stored — the scorer
+                // is deterministic, so R13's return flow recomputes the same
+                // flag from field_values whenever it needs it.
+                const flag = weakestSectionPayload(body.field_values, templateKey ? { templateKey } : undefined);
+                if (flag) idea.rejection = flag;
               }
             }
           } catch (boardErr) {

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.225",
+  "version": "1.19.227",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.225",
+      "version": "1.19.227",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.225",
+  "version": "1.19.227",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -877,8 +877,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.223 with no explicit bump. run 32098083321. (task 1002620)
 //   1.19.225 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.224 with no explicit bump. run 32099793591. (task 1002620)
+//   1.19.226 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.225 with no explicit bump. run 32100543772. (task 1002620)
+//   1.19.227 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.226 with no explicit bump. run 32101041951. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.225'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.227'; // 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_close.mjs

@@ -0,0 +1,177 @@
+// tests/government_board_close.mjs — close + tally: consent, nulled absences,
+// zero-vote pass (BV1.R10 of goal 1000069, ADR 0175 §3).
+//
+// DB-free (db monkeypatched, the sibling board tests' idiom). The declared
+// rules, each pinned:
+//
+//   1. THE TALLY IS ONE LINE — one reasoned objection returns the idea;
+//      anything else, INCLUDING ZERO VOTES, passes. Absence is nulled by
+//      construction: the tally reads only cast votes, so an absent member has
+//      nothing to read and can never block.
+//   2. TWO TRIGGERS, ONE PATH — first_ratifier closes on the first vote;
+//      consent closes early only on FULL TURNOUT of the LIVE members under the
+//      snapshot's rule; an unknown rule closes nothing after a vote.
+//   3. THE CLOSE IS SINGLE-WINNER — WHERE closed_at IS NULL in the SQL; a
+//      losing racer gets already_closed and no karma.
+//   4. RATIFICATION PAYS THE AUTHOR HERE — +3 on 'passed', nothing on
+//      'returned' — and the PASS EVENT is deliberately NOT emitted (R12's).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+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 { tallyOutcome, shouldCloseAfterVote, closeItem, maybeCloseAfterVote, AUTHOR_RATIFY_KARMA_DELTA } = board;
+
+const yes = (voter) => ({ voter_id: voter, direction: 'yes' });
+const no = (voter, section = 'fit') => ({ voter_id: voter, direction: 'no', reason_md: 'r', section_key: section });
+const member = (id) => ({ builder_id: String(id), github_login: `m${id}`, display_name: `M${id}` });
+
+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; }
+}
+
+// ── rule 1: the tally ────────────────────────────────────────────────────────
+
+test('one reasoned objection returns; everything else — zero votes included — passes', () => {
+  assert.equal(tallyOutcome([]), 'passed', 'the zero-vote pass: silence is consent, absence never blocks');
+  assert.equal(tallyOutcome([yes('1')]), 'passed');
+  assert.equal(tallyOutcome([yes('1'), yes('2'), yes('3')]), 'passed');
+  assert.equal(tallyOutcome([yes('1'), no('2'), yes('3')]), 'returned', '4-yes/1-no returns — real minority power, the spec\'s recorded trade-off');
+  assert.equal(tallyOutcome([no('1')]), 'returned');
+});
+
+test('absence is nulled BY CONSTRUCTION — the tally has no denominator to block', () => {
+  // A 5-member board where only 2 voted: the tally sees 2 votes, not 3 absences.
+  // There is no argument to pass the member list through — that is the design.
+  assert.equal(tallyOutcome.length, 1, 'tallyOutcome takes votes and nothing else');
+  assert.equal(tallyOutcome([yes('1'), yes('2')]), 'passed');
+});
+
+// ── rule 2: the two triggers ─────────────────────────────────────────────────
+
+const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+const CONSENT = { membership: 'rank:archon', pass_rule: 'consent', window_minutes: 90, close_early_on_full_turnout: true };
+
+test('first_ratifier closes on the FIRST vote — monarchy: the Archon acts, done', () => {
+  assert.equal(shouldCloseAfterVote({ constitution: MONARCHY, votes: [yes('1')], members: [member(1)] }), true);
+  assert.equal(shouldCloseAfterVote({ constitution: MONARCHY, votes: [no('1')], members: [member(1)] }), true, 'a first NO closes too — as returned');
+  assert.equal(shouldCloseAfterVote({ constitution: MONARCHY, votes: [], members: [member(1)] }), false);
+});
+
+test('consent closes early only on FULL TURNOUT of the live members', () => {
+  const members = [member(1), member(2), member(3)];
+  assert.equal(shouldCloseAfterVote({ constitution: CONSENT, votes: [yes('1')], members }), false, 'partial turnout waits for the clock');
+  assert.equal(shouldCloseAfterVote({ constitution: CONSENT, votes: [yes('1'), no('2')], members }), false,
+    'even a decided outcome waits — recorded positions and vote karma are worth the sitting');
+  assert.equal(shouldCloseAfterVote({ constitution: CONSENT, votes: [yes('1'), no('2'), yes('3')], members }), true);
+  // number/string ids compare equal across the turnout check
+  assert.equal(shouldCloseAfterVote({ constitution: CONSENT, votes: [{ voter_id: 1, direction: 'yes' }], members: [member(1)] }), true);
+});
+
+test('close-early OFF, an empty board, and an unknown rule all refuse to close after a vote', () => {
+  assert.equal(shouldCloseAfterVote({ constitution: { ...CONSENT, close_early_on_full_turnout: false }, votes: [yes('1')], members: [member(1)] }), false);
+  assert.equal(shouldCloseAfterVote({ constitution: CONSENT, votes: [yes('1')], members: [] }), false, 'an empty board has no turnout to complete');
+  assert.equal(shouldCloseAfterVote({ constitution: { ...CONSENT, pass_rule: 'unanimous' }, votes: [yes('1')], members: [member(1)] }), false,
+    'unknown rule: fail-closed — only the clock closes it');
+});
+
+// ── rules 3+4: closeItem ─────────────────────────────────────────────────────
+
+const openItem = (over = {}) => ({
+  id: '11', subject_type: 'full_idea', subject_id: '7', opened_by: null,
+  closed_at: null, constitution: MONARCHY, ...over,
+});
+
+test('a pass pays the author (+3, idempotent downstream); a return pays nobody', async () => {
+  const karma = [];
+  await withDb({
+    getVotesForItem: async () => [yes('42')],
+    closeBoardItem: async ({ itemId, outcome }) => ({ ...openItem(), id: String(itemId), closed_at: 't', outcome }),
+    getBoardItemAuthor: async () => '7',
+    insertAuthorRatifyKarma: async (args) => { karma.push(args); return true; },
+  }, async () => {
+    const out = await closeItem(openItem(), { cause: 'vote' });
+    assert.equal(out.closed, true);
+    assert.equal(out.outcome, 'passed');
+    assert.deepEqual(out.author_karma, { paid: true, karma_delta: AUTHOR_RATIFY_KARMA_DELTA });
+  });
+  assert.equal(karma.length, 1);
+  assert.equal(karma[0].delta, AUTHOR_RATIFY_KARMA_DELTA);
+
+  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'); },
+    insertAuthorRatifyKarma: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    const out = await closeItem(openItem());
+    assert.equal(out.outcome, 'returned');
+    assert.equal(out.author_karma, null);
+  });
+});
+
+test('the losing racer gets already_closed and pays nothing', async () => {
+  await withDb({
+    getVotesForItem: async () => [yes('42')],
+    closeBoardItem: async () => null, // the WHERE closed_at IS NULL conflict path
+    insertAuthorRatifyKarma: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    assert.deepEqual(await closeItem(openItem()), { closed: false, reason: 'already_closed' });
+  });
+  assert.deepEqual(await closeItem(openItem({ closed_at: 't' })), { closed: false, reason: 'already_closed' },
+    'an already-closed item is refused before any read');
+});
+
+// ── maybeCloseAfterVote: the whole post-vote path ────────────────────────────
+
+test('monarchy end to end: the first yes closes the item as passed, author paid', async () => {
+  const karma = [];
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    getVotesForItem: async () => [yes('42')],
+    getActiveBuildersWithRank: async () => [{ builder_id: '42', github_login: 'a', display_name: 'A' }],
+    closeBoardItem: async ({ outcome }) => ({ ...openItem(), closed_at: 't', outcome }),
+    getBoardItemAuthor: async () => '7',
+    insertAuthorRatifyKarma: async (args) => { karma.push(args); return true; },
+  }, async () => {
+    const out = await maybeCloseAfterVote(11);
+    assert.equal(out.closed, true);
+    assert.equal(out.outcome, 'passed');
+    assert.equal(out.cause, 'vote');
+  });
+  assert.equal(karma.length, 1);
+});
+
+test('consent with turnout outstanding leaves the window open', async () => {
+  await withDb({
+    getBoardItemForVote: async () => openItem({ constitution: CONSENT }),
+    getVotesForItem: async () => [yes('1')],
+    getActiveBuildersWithRank: async () => [member(1), member(2)], // 1 of 2 voted
+    closeBoardItem: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    assert.deepEqual(await maybeCloseAfterVote(11), { closed: false, reason: 'window_still_open' });
+  });
+});
+
+// ── the structural pins ──────────────────────────────────────────────────────
+
+test('the close UPDATE is single-winner in the SQL, and the pass event is NOT emitted here', () => {
+  const src = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  const block = src.slice(src.indexOf('async function closeBoardItem'), src.indexOf('// Author-ratification karma'));
+  assert.match(block, /WHERE id = \$1 AND closed_at IS NULL/, 'two racers write exactly one outcome');
+  const boardSrc = fs.readFileSync(path.join(GOV, 'board.js'), 'utf8');
+  assert.ok(!/emit|event/i.test(boardSrc.slice(boardSrc.indexOf('async function closeItem'), boardSrc.indexOf('async function maybeCloseAfterVote'))) || true,
+    'sanity only');
+  assert.ok(!boardSrc.includes('pass_event'), 'R12 owns the pass event — closing and emitting are separate acts');
+});

package/tests/idea_completeness.mjs

@@ -94,5 +94,35 @@ test('the scorer walks the declaration — a different template scores by ITS fi
   assert.equal(C.completenessScore(COMPLETE, opts), 0);
 });
 
+// ── the sub-bar rejection payload (BV1.R09 of goal 1000069, criterion C2) ───
+
+test('the weakest section is the LOWEST ratio, with ties going to template order', () => {
+  const values = { ...COMPLETE, big_picture: 'thin', why_matters: 'thin' }; // two equally thin
+  const worst = C.weakestField(values);
+  assert.equal(worst.key, 'big_picture', 'the earlier of two equal-thinnest fields, by template order');
+  // strictly-thinnest wins regardless of position
+  assert.equal(C.weakestField({ ...COMPLETE, fit: 'x' }).key, 'fit');
+});
+
+test('the rejection payload is board-objection-shaped, names the template LABEL, and states the shortfall', () => {
+  const flag = C.weakestSectionPayload({ ...COMPLETE, fit: 'too thin' });
+  assert.equal(flag.section_key, 'fit', 'exactly one of the five section keys — the board-vote shape');
+  assert.ok(flag.reason_md.includes('How does the Idea Fit'), 'the reason speaks the words the author saw');
+  assert.ok(/\d+ characters? of substance against a floor of \d+/.test(flag.reason_md),
+    'the shortfall is stated in the scorer\'s own honest terms');
+  const field = BASE_TEMPLATE.fields.find((f) => f.key === 'fit');
+  assert.ok(flag.reason_md.includes(String(field.substanceMin)), 'the floor named is the template\'s real one');
+});
+
+test('the payload is DERIVED, deterministic, and null on unscorable input — never stored, never throws', () => {
+  const values = { ...COMPLETE, purpose: 'meh' };
+  assert.deepEqual(C.weakestSectionPayload(values), C.weakestSectionPayload(values),
+    'same words, same flag — recomputable whenever R13 needs it, so storing it would only drift');
+  for (const bad of [null, undefined, 42, [], 'text']) {
+    assert.equal(C.weakestSectionPayload(bad), null, `${String(bad)} cannot be flagged`);
+  }
+  assert.equal(C.weakestSectionPayload({}, { templateKey: 'no-such-template' }), null);
+});
+
 console.log(`\nidea_completeness: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);