@bongos/core 1.19.466 → 1.19.467

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.466",
-  "core_contract": "1.19.466",
-  "source_commit": "5b915c14235b08df52728e3d94dc196d548791a3",
+  "core_version": "1.19.467",
+  "core_contract": "1.19.467",
+  "source_commit": "ca27d74624afc9f0a8310e29b2efaa2c5bb993c8",
   "source_ref": "HEAD",
-  "built_at": "2026-09-02T02:25:23.295Z",
+  "built_at": "2026-09-02T13:55:51.607Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 407,
     "agent_docs_stubbed": 24,
-    "functional_verbatim": 1822,
+    "functional_verbatim": 1823,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2253,
-  "tree_sha256": "4bb527a26dc80efbf88ff9d1a853737b1a657a8f300f8fbf01e76b4146834f58",
+  "file_count": 2254,
+  "tree_sha256": "8d432d170e40887e5a113bf2531114e2e0b29f4e8dd8aada1b61ae25b764b597",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -2122,7 +2122,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "5e800493043ac5941fa8ed5f9efc66359a0622f79968fd7158a61651556c1cf3"
+      "sha256": "f5622e8a177e977aedade86d47f76e7669f2f417a1d88d5cd63c66949fe9d8c2"
     },
     {
       "path": "docs/modules-contract.md",
@@ -3612,7 +3612,7 @@
     {
       "path": "modules/economy/credits.js",
       "mode": "0000644",
-      "sha256": "2269a87709349cd410bad2714189788d24c1edff3e654af5b47aacb93c415cdb"
+      "sha256": "06f1cc7080509864ea4f474627a7a35de8348fcf4f935a13fc62da38e2a67fa8"
     },
     {
       "path": "modules/economy/migrations/economy_001_fix_gds_shipper_description.sql",
@@ -3632,7 +3632,7 @@
     {
       "path": "modules/economy/reward.js",
       "mode": "0000644",
-      "sha256": "59952daf3cb8cadc33f5249fb07552949d390ba37c71299117a2d503f83e422a"
+      "sha256": "13cc932402c3cf0d2154507c6e6a462aeb98520a2214b8561ec01a6bb9245fd6"
     },
     {
       "path": "modules/economy/routes/cost.js",
@@ -6622,12 +6622,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "098654f260139d3b7b4d45ef87d7a15c3ca8a0ebb04ce36ba538e212c3dce351"
+      "sha256": "fecffff8fe1b80ab540c5212c13d5056d722e897b824afdc2ebeaae24738935b"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "9670afc099badbbc922edd16e4cb6a1a99d370267cc15b2232af678b6c65f7b0"
+      "sha256": "f4a08b3e124eba41cb2e39cea9a79ede0858c5e1496f2ce1531030814df04d12"
     },
     {
       "path": "public-docs/index.html",
@@ -8277,7 +8277,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "400ed351948806a44d6558bbc10d35158237d80c3101415acebb6d075747c3ae"
+      "sha256": "30e8f24ef0a0f45e8c4172c98daee61756ba74acf0d55f100ae8cc6c7b7540e2"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -9794,6 +9794,11 @@
       "mode": "0000644",
       "sha256": "63afe2afd59ff64e290234a0cc8d33a0f77b784d8c10c2d7147fe2ab3c114cd1"
     },
+    {
+      "path": "tests/idea_governance_pass_credit.mjs",
+      "mode": "0000644",
+      "sha256": "75af0cfce88da50c74a1c499e7308774b70eb05e31a3274246dd6b4c8fdb1b34"
+    },
     {
       "path": "tests/idea_grades.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -1369,5 +1369,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.464 with no explicit bump. run 33581328823. (task 1002620)
   1.19.466 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.465 with no explicit bump. run 33583122775. (task 1002620)
+  1.19.467 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.466 with no explicit bump. run 33638703282. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/economy/credits.js

@@ -119,6 +119,11 @@ const IDEA_FULL_PASS_CREDIT = 5;   // owner: "gives 5 credits"
 const IDEA_FULL_PASS_BAR = 60;     // completeness 0-100; ADR 0172 proposed default
 const IDEA_TASK_SHIP_BASE = 5;     // stream 1: base credit per shipped task under an idea
 const QUICK_IDEA_FACTOR = 0.6;     // a quick/spark idea's grade factor (ADR 0172 default)
+// Stream 3 (IC5): a board-ratified Full Idea pays a share of a 100-credit
+// ceiling, in proportion to how complete the idea was. Owner: "30-100 credits
+// ... paid as a percent on the 100 credits for its fullness."
+const IDEA_GOVERNANCE_PASS_MAX = 100;   // owner: "up to 100 credits"
+const IDEA_GOVERNANCE_PASS_FLOOR = 30;  // owner: floor ~30 — see the note on the award fn
 
 // =========================================================================
 // Session token reward (flat cost-plus) — task 1005 (ADR 0054).
@@ -577,6 +582,114 @@ async function awardIdeaTaskShipCredit(client, { taskId, config = rewardConfig()
     : { credited: 0, reason: 'already_paid', ideaId: Number(ideaId), authorId: Number(authorId) };
 }
 
+// Stream 3 (ADR 0172 / goal 1000067 IC5): a Full Idea that PASSES the Board
+// Room's ratification vote pays a share of a 100-credit ceiling, scaled by the
+// idea's R142 completeness — "70%-complete + passes = 70". The ideator lane, so
+// it gates on config.ideatorCredit, never perTaskCredit.
+//
+// THE BOARD CALLS THIS THROUGH THE `reward` PORT, INSIDE ITS CLOSE TRANSACTION
+// (docs/specs/board-room-pass-event-contract.md, Decision 1) — not off the
+// `board.item.passed` seam event, because emitAsync swallows listener errors,
+// which is right for a Discord post and disqualifying for a payment. If this
+// write fails the close rolls back and the item stays open, so the vote is
+// retried rather than the author silently unpaid.
+//
+// RE-DRIVABLE BY DESIGN (contract Decision 5): the durable fact is the
+// `board_items` row with outcome='passed', not a delivered event. Nothing here
+// reads board state or requires a live listener, and the reason key makes a
+// blanket re-run safe, so a missed award can be reconciled by sweeping the
+// passed items and calling this again. No such sweep is scheduled in v1 — the
+// requirement is only that the shape permits one.
+//
+//   client             — pg client / pool (transaction participant)
+//   ideaId, authorId   — the ratified idea and its captured_by builder
+//   completenessScore  — the R142 score (0-100)
+//   subjectType        — the board subject, when the caller knows it; only
+//                        'full_idea' pays (contract Decision 2). Omitted means
+//                        "already filtered", which is how the board calls it.
+//   config             — resolved reward policy; gates on config.ideatorCredit
+//
+// Returns { credited, reason }:
+//   { credited: N, reason: 'paid' }                 — first pass for this idea
+//   { credited: 0, reason: 'already_paid' }         — a prior row for this idea
+//   { credited: 0, reason: 'not_a_full_idea' }      — an amendment pays nothing
+//   { credited: 0, reason: 'ideator_lane_off' }     — instance opted the lane out
+//   { credited: 0, reason: 'missing_author_or_idea' }
+//   { credited: 0, reason: 'no_completeness_score' }
+//
+// NO `below_bar` RETURN, deliberately (contract Decision 4): ADR 0175 §5 makes
+// the completeness bar the gate on OPENING a vote window at all, so an idea
+// below the bar can never reach a pass. Re-checking it here would imply the
+// board might send something it cannot.
+async function awardIdeaGovernancePassCredit(client, {
+  ideaId, authorId, completenessScore, subjectType, config = rewardConfig(),
+} = {}) {
+  // SUBJECT TYPE FIRST, ahead of the lane check that opens both sibling streams:
+  // a constitutional amendment traverses the same close path and is not an
+  // ideator payment at all, so whether the ideator lane is on is irrelevant to
+  // it. A re-drive sweep reading these reasons gets the truthful one.
+  if (subjectType != null && subjectType !== 'full_idea') {
+    return { credited: 0, reason: 'not_a_full_idea' };
+  }
+  if (config && config.ideatorCredit === false) {
+    return { credited: 0, reason: 'ideator_lane_off' };
+  }
+  if (ideaId == null) {
+    return { credited: 0, reason: 'missing_author_or_idea' };
+  }
+  if (completenessScore == null || !Number.isFinite(Number(completenessScore))) {
+    return { credited: 0, reason: 'no_completeness_score' };
+  }
+  // The parties come from the DB, not the call site (the R147 rule): there is
+  // exactly one place that decides who earns from an idea. `authorId` is a
+  // fallback for a caller holding an idea this lookup cannot see.
+  const parties = await ideaCreditParties(client, ideaId);
+  const resolvedAuthor = (parties && parties.authorId != null) ? parties.authorId : authorId;
+  if (resolvedAuthor == null) {
+    return { credited: 0, reason: 'missing_author_or_idea' };
+  }
+  // CLAMPED to [0,1] before scaling, so a malformed score can never pay out
+  // more than the ceiling (the stream-1 precedent). The floor then applies:
+  // it is UNREACHABLE under default config — ADR 0175 §5 gates window-opening
+  // on IDEA_FULL_PASS_BAR (60), so a real payout lands in [60,100] and max()
+  // never binds — but it ships because it is the owner's stated intent and goes
+  // live the moment either constant moves.
+  const pct = Math.max(0, Math.min(1, Number(completenessScore) / 100));
+  const delta = Math.max(
+    IDEA_GOVERNANCE_PASS_FLOOR,
+    Math.round(pct * IDEA_GOVERNANCE_PASS_MAX)
+  );
+  // Split with whoever DEVELOPED the spark, the same 70/30 as streams 1 and 2
+  // (ADR 0185) — the contract predates that split and names the author alone;
+  // mirroring the sibling streams, as it asks, means splitting here too.
+  const payees = splitIdeaCredit(delta, {
+    authorId: resolvedAuthor,
+    developedBy: parties ? parties.developedBy : null,
+  });
+  if (payees.length === 0) {
+    return { credited: 0, reason: 'zero_after_scaling' };
+  }
+  // ONCE PER IDEA, FOREVER. A resubmission that passes again, a re-close, a
+  // replay, or a concurrent request all resolve to this same key and book
+  // nothing further. Builder-scoped so the NOT EXISTS hits
+  // idx_credit_log_builder (credit_log is a CORE table — a module migration may
+  // not add an index on `reason`), and because a split books one row per payee
+  // under ONE reason, a reason-only predicate would refuse the second payee.
+  // task_id is NULL: an idea credit has no task.
+  const reason = `idea.credit.governance_pass:${ideaId}`;
+  const scorePct = Math.round(Number(completenessScore));
+  const { credited, payees: booked } = await bookIdeaSplit(client, {
+    payees,
+    reason,
+    describe: (p) => `Full Idea #${ideaId} ratified by the board (completeness ${scorePct}/100) → ${p.delta}c to its ${p.role.replace(/_/g, ' ')} (ideator lane stream 3, ADR 0172${p.role === 'developer' || p.role === 'spark_author' ? '; split ADR 0185' : ''})`,
+  });
+  return {
+    credited,
+    reason: credited > 0 ? 'paid' : 'already_paid',
+    payees: booked,
+  };
+}
+
 // Award the flat cost-plus session token reward, idempotent per session_id
 // (task 1005, ADR 0054). Called inside the same transaction as the session
 // upsert (see upsertSessionRecordWithReward).
@@ -824,6 +937,7 @@ module.exports = {
   maybeAwardIdeaPromotionBonus,
   awardIdeaFullPassCredit,
   awardIdeaTaskShipCredit,
+  awardIdeaGovernancePassCredit,
   // the spark-handoff split (task 1002923 / BV1.R147, ADR 0185)
   splitIdeaCredit,
   IDEA_DEVELOPER_SHARE,
@@ -831,6 +945,8 @@ module.exports = {
   IDEA_FULL_PASS_BAR,
   IDEA_TASK_SHIP_BASE,
   QUICK_IDEA_FACTOR,
+  IDEA_GOVERNANCE_PASS_MAX,
+  IDEA_GOVERNANCE_PASS_FLOOR,
   awardSessionTokenReward,
   NET_NEGATIVE_BONUS,
   SUBTRACTOR_THRESHOLD,

package/modules/economy/reward.js

@@ -28,6 +28,11 @@ module.exports = {
   awardIdeaFullPassCredit: (...a) => credits.awardIdeaFullPassCredit(...a),
   // ADR 0172 IC4 — stream 1: pay the idea's author per shipped task, grade-scaled (replaces the 25% slice at ship).
   awardIdeaTaskShipCredit: (...a) => credits.awardIdeaTaskShipCredit(...a),
+  // ADR 0172 IC5 — stream 3: a board-ratified Full Idea pays up to 100, scaled by completeness.
+  // The board's close transaction resolves this port and calls this with its own
+  // `client` (docs/specs/board-room-pass-event-contract.md) — the port is how
+  // money crosses the wall; the `board.item.passed` event never carries a payment.
+  awardIdeaGovernancePassCredit: (...a) => credits.awardIdeaGovernancePassCredit(...a),
   awardNetNegativeBonus: (...a) => credits.awardNetNegativeBonus(...a),
   awardSessionTokenReward: (...a) => credits.awardSessionTokenReward(...a),
   // gamification hooks the lifecycle fires at claim/ship

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.466",
+  "version": "1.19.467",
   "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

@@ -33,7 +33,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.466'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.467'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/idea_governance_pass_credit.mjs

@@ -0,0 +1,243 @@
+// tests/idea_governance_pass_credit.mjs
+//
+// task 1002999 (BV1.R175 / IC5, goal 1000067) — stream 3 of the ideator credit
+// lane: a Full Idea that PASSES the Board Room's ratification vote pays a share
+// of a 100-credit ceiling, scaled by its R142 completeness. ADR 0172 §3, and
+// docs/specs/board-room-pass-event-contract.md (the agreement with the board).
+//
+// The done-when as assertions: a ratified Full Idea books round(completeness%)
+// once; a constitutional amendment books nothing; re-running never double-pays;
+// cost-plus-only does NOT suppress it (it gates on ideatorCredit, never
+// perTaskCredit); an instance that opts the ideator lane out pays nothing.
+//
+// The credit fn is exercised over a stub client that records statements and
+// simulates the WHERE-NOT-EXISTS idempotency, so the idempotency logic is proven
+// without a DB — the tests/idea_full_pass_credit.mjs harness, unchanged.
+//
+// Run:  node tests/idea_governance_pass_credit.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const credits = require('../modules/economy/credits.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// A stub client whose credit_log "table" is an in-memory set of (builder, reason)
+// pairs, so INSERT ... WHERE NOT EXISTS behaves exactly like Postgres: a second
+// insert for the same pair is a no-op (rowCount 0). `developedBy` defaults to
+// null — an idea nobody else developed — and is set explicitly by the split test.
+function stubClient({ authorId = null, developedBy = null } = {}) {
+  const rows = [];
+  return {
+    rows,
+    async query(sql, params) {
+      // The parties lookup — who authored this idea, and who developed it.
+      if (/FROM idea_inbox i/i.test(sql) && /developed_by/i.test(sql)) {
+        return { rows: authorId == null ? [] : [{ captured_by: authorId, developed_by: developedBy }] };
+      }
+      // The idempotency predicate must scope by builder_id AND reason: a split
+      // books two rows under ONE reason, so a reason-only predicate would
+      // silently refuse the second payee (and credit_log is a CORE table, so a
+      // module migration cannot add an index on `reason` anyway).
+      const builderId = params[0];
+      const reason = params[3];
+      assert.match(sql, /builder_id = \$1 AND reason = \$4/, 'idempotency check must scope by builder_id AND reason');
+      const exists = rows.some((r) => r.builder_id === builderId && r.reason === reason);
+      if (exists) return { rowCount: 0, rows: [] };
+      rows.push({ builder_id: builderId, task_id: params[1], delta: params[2], reason, description: params[4] });
+      return { rowCount: 1, rows: [] };
+    },
+  };
+}
+
+const ON = { ideatorCredit: true };
+
+await test('a ratified Full Idea pays its completeness percent of the 100 ceiling', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 9, authorId: 3, completenessScore: 70, config: ON });
+  assert.equal(r.credited, 70, 'the owner\'s worked example: 70%-complete + passes = 70');
+  assert.equal(r.reason, 'paid');
+  assert.equal(c.rows.length, 1);
+  assert.equal(c.rows[0].delta, 70);
+  assert.equal(c.rows[0].builder_id, 3);
+  assert.equal(c.rows[0].reason, 'idea.credit.governance_pass:9');
+  assert.equal(c.rows[0].task_id, null, 'an idea credit has no task');
+});
+
+await test('a fully-complete idea pays the whole 100-credit ceiling, never more', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 1, authorId: 3, completenessScore: 100, config: ON });
+  assert.equal(r.credited, credits.IDEA_GOVERNANCE_PASS_MAX);
+  assert.equal(r.credited, 100);
+});
+
+await test('a malformed over-100 score is clamped to the ceiling, not paid out', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 2, authorId: 3, completenessScore: 420, config: ON });
+  assert.equal(r.credited, 100, 'the ceiling holds even when the input is nonsense');
+});
+
+await test('re-running pays nothing — once per idea, forever', async () => {
+  const c = stubClient({ authorId: 3 });
+  const opts = { ideaId: 9, authorId: 3, completenessScore: 80, config: ON };
+  const first = await credits.awardIdeaGovernancePassCredit(c, opts);
+  const second = await credits.awardIdeaGovernancePassCredit(c, opts);
+  const third = await credits.awardIdeaGovernancePassCredit(c, opts);
+  assert.equal(first.credited, 80);
+  assert.equal(second.credited, 0);
+  assert.equal(second.reason, 'already_paid');
+  assert.equal(third.credited, 0);
+  assert.equal(c.rows.length, 1, 'exactly one credit_log row ever, across three calls');
+});
+
+await test('a constitutional amendment books nothing — subject_type is load-bearing', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, {
+    ideaId: null, authorId: 3, completenessScore: null,
+    subjectType: 'constitutional_amendment', config: ON,
+  });
+  assert.equal(r.credited, 0);
+  assert.equal(r.reason, 'not_a_full_idea');
+  assert.equal(c.rows.length, 0, 'an amendment traverses the same close path and must pay nobody');
+});
+
+await test('subject_type is checked BEFORE the lane flag, so a sweep gets the truthful reason', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, {
+    ideaId: 5, authorId: 3, completenessScore: 90,
+    subjectType: 'constitutional_amendment', config: { ideatorCredit: false },
+  });
+  assert.equal(r.reason, 'not_a_full_idea', 'an amendment is not an ideator payment at all');
+});
+
+await test('an explicit full_idea subject pays exactly as an omitted one does', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, {
+    ideaId: 7, authorId: 3, completenessScore: 65, subjectType: 'full_idea', config: ON,
+  });
+  assert.equal(r.credited, 65, 'the board omits subjectType because it has already filtered; a sweep passes it');
+});
+
+await test('COST-PLUS-ONLY does NOT suppress it: the ideator lane pays regardless of perTaskCredit', async () => {
+  // the live cloudbongos.com policy: builder estimate off, ideator lane on
+  const policy = credits.rewardPolicy({ mode: 'cost-plus-only' });
+  assert.equal(policy.perTaskCredit, false);
+  assert.equal(policy.ideatorCredit, true);
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 5, authorId: 3, completenessScore: 75, config: policy });
+  assert.equal(r.credited, 75, 'paid despite cost-plus-only — this is the whole point of ADR 0172');
+});
+
+await test('an instance that opts the ideator lane out pays nothing', async () => {
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 6, authorId: 3, completenessScore: 90, config: { ideatorCredit: false } });
+  assert.equal(r.credited, 0);
+  assert.equal(r.reason, 'ideator_lane_off');
+  assert.equal(c.rows.length, 0);
+});
+
+await test('an unscorable idea books 0 — and it is NOT reported as below a bar', async () => {
+  // There is deliberately no `below_bar` return: ADR 0175 §5 makes the
+  // completeness bar the gate on OPENING a window, so a sub-bar idea can never
+  // reach a pass. A null score means the score is MISSING, not low.
+  const c = stubClient({ authorId: 3 });
+  assert.equal((await credits.awardIdeaGovernancePassCredit(c, { ideaId: 1, authorId: 3, completenessScore: null, config: ON })).reason, 'no_completeness_score');
+  assert.equal((await credits.awardIdeaGovernancePassCredit(c, { ideaId: 2, authorId: 3, completenessScore: undefined, config: ON })).reason, 'no_completeness_score');
+  assert.equal((await credits.awardIdeaGovernancePassCredit(c, { ideaId: 3, authorId: 3, completenessScore: 'x', config: ON })).reason, 'no_completeness_score');
+  assert.equal(c.rows.length, 0, 'nothing written when there is no score to scale by');
+});
+
+await test('a missing author or idea is a safe 0, never a throw', async () => {
+  const noIdea = stubClient({ authorId: 3 });
+  assert.equal((await credits.awardIdeaGovernancePassCredit(noIdea, { ideaId: null, authorId: 3, completenessScore: 90, config: ON })).reason, 'missing_author_or_idea');
+  // An idea the lookup cannot see AND no caller-supplied author → still a safe 0.
+  const unknown = stubClient();   // lookup returns no row
+  assert.equal((await credits.awardIdeaGovernancePassCredit(unknown, { ideaId: 6, authorId: null, completenessScore: 90, config: ON })).reason, 'missing_author_or_idea');
+  assert.equal(unknown.rows.length, 0);
+});
+
+await test('the DB is authoritative for the author; the argument is only a fallback', async () => {
+  const known = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(known, { ideaId: 6, authorId: null, completenessScore: 90, config: ON });
+  assert.equal(r.credited, 90);
+  assert.equal(known.rows[0].builder_id, 3, 'paid the author the DB names');
+
+  // ...and when the lookup finds nothing, the passed author is still honoured,
+  // so a caller holding an idea this module cannot see is not silently unpaid.
+  const invisible = stubClient();
+  const f = await credits.awardIdeaGovernancePassCredit(invisible, { ideaId: 6, authorId: 7, completenessScore: 90, config: ON });
+  assert.equal(f.credited, 90);
+  assert.equal(invisible.rows[0].builder_id, 7);
+});
+
+await test('a developed spark splits 70/30 with its developer, conserving the total', async () => {
+  // ADR 0185, the same rule streams 1 and 2 apply. The contract for this stream
+  // predates the split and names the author alone; mirroring the sibling
+  // streams, as it asks, means splitting here too.
+  const c = stubClient({ authorId: 3, developedBy: 8 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 4, authorId: 3, completenessScore: 70, config: ON });
+  assert.equal(r.credited, 70, 'the total is conserved across the two payees');
+  assert.equal(c.rows.length, 2);
+  const dev = c.rows.find((x) => x.builder_id === 8);
+  const author = c.rows.find((x) => x.builder_id === 3);
+  assert.equal(dev.delta, 49, '70% of 70, rounded');
+  assert.equal(author.delta, 21, 'the remainder — never independently rounded');
+  assert.equal(dev.reason, author.reason, 'one reason key, two rows — hence the builder-scoped predicate');
+});
+
+await test('a self-developed spark collapses to one payee, so nobody is under-paid', async () => {
+  const c = stubClient({ authorId: 3, developedBy: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 11, authorId: 3, completenessScore: 70, config: ON });
+  assert.equal(r.credited, 70);
+  assert.equal(c.rows.length, 1, 'two rows for one builder would hit the idempotency predicate and UNDER-pay');
+});
+
+await test('the floor pays 30 on a sub-30 score — a branch unreachable under default config', async () => {
+  // NOT A REAL SCENARIO, and deliberately not faked into one: ADR 0175 §5 gates
+  // window-opening on IDEA_FULL_PASS_BAR, so a real payout lands in [60,100]
+  // and max() never binds. The branch is exercised by handing the function an
+  // input the board cannot currently send — never by lowering the bar in a
+  // fixture, which would look like a scenario it is not. It ships because it is
+  // the owner's stated intent and goes live the moment either constant moves.
+  const c = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaGovernancePassCredit(c, { ideaId: 12, authorId: 3, completenessScore: 10, config: ON });
+  assert.equal(r.credited, credits.IDEA_GOVERNANCE_PASS_FLOOR);
+  assert.equal(r.credited, 30);
+});
+
+await test('the floor really is unreachable at the shipped constants — the finding, as an assertion', async () => {
+  const lowestPassablePayout = Math.round(credits.IDEA_FULL_PASS_BAR / 100 * credits.IDEA_GOVERNANCE_PASS_MAX);
+  assert.ok(
+    lowestPassablePayout > credits.IDEA_GOVERNANCE_PASS_FLOOR,
+    `bar ${credits.IDEA_FULL_PASS_BAR} pays ${lowestPassablePayout}, above the ${credits.IDEA_GOVERNANCE_PASS_FLOOR} floor — if this ever fails, the floor has become live and the branch above is a real scenario`
+  );
+});
+
+await test('all three ideator streams use distinct reason keys, so one idea can earn on each', async () => {
+  const c = stubClient({ authorId: 3 });
+  await credits.awardIdeaFullPassCredit(c, { ideaId: 20, authorId: 3, completenessScore: 90, config: ON });
+  await credits.awardIdeaGovernancePassCredit(c, { ideaId: 20, authorId: 3, completenessScore: 90, config: ON });
+  assert.equal(c.rows.length, 2, 'stream 2 and stream 3 both paid the same idea');
+  assert.equal(c.rows[0].reason, 'idea.credit.full_pass:20');
+  assert.equal(c.rows[1].reason, 'idea.credit.governance_pass:20');
+  assert.equal(c.rows[0].delta + c.rows[1].delta, 95, '5 for the grade, 90 for the ratification');
+});
+
+await test('the award rides the reward PORT, so the board can resolve it', async () => {
+  const reward = require('../modules/economy/reward.js');
+  assert.equal(typeof reward.awardIdeaGovernancePassCredit, 'function',
+    'board.js duck-types on exactly this name; without it the close is a silent no-op');
+  const c = stubClient({ authorId: 3 });
+  const r = await reward.awardIdeaGovernancePassCredit(c, { ideaId: 30, authorId: 3, completenessScore: 60, config: ON });
+  assert.equal(r.credited, 60, 'delegated, not spread — the port reaches the live function');
+});
+
+console.log(`\nidea_governance_pass_credit: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);