@bongos/core 1.19.472 → 1.19.474

package/tests/hall_reference_world.mjs

@@ -0,0 +1,222 @@
+// tests/hall_reference_world.mjs — the REFERENCE room in the chrome world:
+// drachmae, and what the reading-room archetype owes a second document
+// (task 1003473, goal 1000081).
+//
+// tests/hall_reading_world.mjs pins the reading rooms (the primer, the diagrams
+// index, the deck, the ladder); this is the same job for the one document
+// people SCAN rather than read. Everything here is a fact that is silent in a
+// browser: the page still renders, it just renders the primer's instruments on
+// a document that has no end to reach, or an outline that stops one level
+// short of the questions people came with.
+//
+// What it locks:
+//   * ONE ROOM, ONE MODIFIER. drachmae opts into `room room--reference` and
+//     loads room.css alone. primer.css holds only the acknowledge gate and
+//     was loaded here for nothing; the reference rules live in room.css §8, so
+//     the next scanned document takes them by one body class.
+//   * THE LINEAR-READ INSTRUMENTS ARE OFF. No progress hairline, no section
+//     counters, no "About a five-minute read" — and the primer keeps all three.
+//   * THE OUTLINE GOES TO h3 DEPTH and lights the entry AND its part.
+//   * EVERY HEADING IS AN ADDRESS. `.room-anchor` on h2/h3/h4, a 24px box of
+//     its own, copying the absolute link on click; a deep link lands after the
+//     async render, or the browser's own jump finds nothing.
+//   * THE PARSER REACHES h4, and a heading that carries a link slugs by its
+//     text. The economy doc's six earning sources are `####`, and the shared
+//     reader stopped at `###`, so they rendered as paragraphs with a literal
+//     "####" — the largest defect on the page, and invisible to every floor.
+//   * NESTED EMPHASIS RENDERS. "**It's the API *list* price**" showed its
+//     asterisks because the bold rule refused an inner `*`.
+//   * THE LIVE TABLE IS A SECTION AHEAD OF THE CLOSING LINKS, not an appendix
+//     after "dig deeper".
+//
+// Reproduce the renders these came from (the populated document needs the
+// fixture harness; the kit stub serves neither the markdown nor the bounty feed):
+//   node scripts/hall-preview/server.js --port 4620 --fixture-me
+//   node modules/ui-design/kit/render.js --states modules/hall-ui/public/drachmae.states.json \
+//     --base-in http://builders.localhost:4620 --base-out http://builders.localhost:4620
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+
+const roomCss = read('room.css');
+const mdReaderJs = read('md-reader.js');
+const drachmaeHtml = read('drachmae.html');
+const drachmaeJs = read('drachmae.js');
+const drachmaeStates = JSON.parse(read('drachmae.states.json'));
+const primerHtml = read('primer.html');
+const primerJs = read('primer.js');
+
+const decomment = (css) => css.replace(/\/\*[\s\S]*?\*\//g, '');
+const dehtmlcomment = (html) => html.replace(/<!--[\s\S]*?-->/g, '');
+const dejscomment = (js) => js.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
+// The body of the first rule matching `selector {`, comments stripped. Takes a
+// PLAIN selector and escapes it here.
+const rule = (css, selector) => {
+  const esc = selector.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const m = decomment(css).match(new RegExp(`(^|[},])\\s*${esc}\\s*\\{([^}]*)\\}`, 'm'));
+  return m ? m[2] : null;
+};
+
+// md-reader.js is a browser IIFE that only touches `window` and `location`.
+function loadReader() {
+  const sandbox = { window: {}, location: { hostname: 'builders.example.com', href: 'https://builders.example.com/drachmae' } };
+  vm.createContext(sandbox);
+  vm.runInContext(mdReaderJs, sandbox, { filename: 'md-reader.js' });
+  return sandbox.window.OTBMdReader;
+}
+
+// ---- 1. one room, one modifier ----------------------------------------------
+
+test('drachmae opts into the room and its reference rules, and loads the archetype sheet alone', () => {
+  assert.match(drachmaeHtml, /<body class="room room--reference"/, 'the reference is the room with one modifier, not a second archetype');
+  assert.match(drachmaeHtml, /href="\/builders\/room\.css"/, 'the archetype is loaded');
+  assert.doesNotMatch(dehtmlcomment(drachmaeHtml), /primer\.css/,
+    'primer.css holds only the acknowledge gate, which a reference has no use for');
+  assert.match(drachmaeHtml, /class="page-head page-head--room"/, 'the head keeps the room voice');
+});
+
+test('the reference rules live in room.css, keyed on the body modifier', () => {
+  const css = decomment(roomCss);
+  assert.match(css, /\.room--reference \.primer-article h2::before,\s*\.room--reference \.primer-toc__list a::before\s*\{\s*content:\s*none/,
+    'the counters are off on a reference');
+  assert.ok(rule(roomCss, '.room--reference .primer-toc__sub'), 'the nested contents have a rule');
+  assert.ok(rule(roomCss, '.room--reference .primer-toc__list a.is-trail'), 'the part of the lit entry is the trail');
+  assert.match(rule(roomCss, '.primer-article h2::before') || '', /counter-increment/,
+    'and the primer keeps its counter — the modifier turns it off, the archetype still draws it');
+});
+
+// ---- 2. the linear-read instruments are off ---------------------------------
+
+test('the reference carries no progress hairline, no acknowledge gate and no read time', () => {
+  const html = dehtmlcomment(drachmaeHtml);
+  assert.doesNotMatch(html, /primer-progress/, 'no progress hairline: a reference has no end to reach');
+  assert.doesNotMatch(dejscomment(drachmaeJs), /primer-progress|setupProgressBar/, 'and the script drives none');
+  assert.doesNotMatch(html, /primer-ack/, 'no acknowledge gate');
+  assert.doesNotMatch(html, /minute read/i, 'the sub line says what kind of document this is, not how long it takes');
+});
+
+test('the primer keeps all three — the modifier is drachmae\'s, not the room\'s', () => {
+  assert.doesNotMatch(primerHtml, /room--reference/);
+  assert.match(primerHtml, /primer-progress__bar/);
+  assert.match(primerJs, /function setupProgressBar/, 'the primer\'s gate is fed by its progress');
+});
+
+// ---- 3. the outline -----------------------------------------------------------
+
+test('the outline is read from the rendered h2s AND h3s and nests them', () => {
+  assert.match(drachmaeJs, /querySelectorAll\('h2\[id\], h3\[id\]'\)/, 'the contents are collected from the DOM, to h3 depth');
+  assert.match(drachmaeJs, /class="primer-toc__sub"/, 'h3s nest under their part');
+  assert.match(drachmaeJs, /classList\.toggle\('is-trail'/, 'the spy marks the lit entry\'s part');
+  assert.match(drachmaeHtml, /id="primer-toc-current"/, 'the phone toggle has a middle that names the part');
+  assert.match(drachmaeJs, /current\.textContent = active \? active\.part : ''/, 'and the spy writes it');
+});
+
+test('the toggle\'s chevron is drawn, and the contents are named for a reference', () => {
+  assert.doesNotMatch(dehtmlcomment(drachmaeHtml), /▾/, 'no glyph standing in for an icon');
+  assert.match(drachmaeHtml, /<svg class="primer-toc__chevron"/);
+  assert.match(drachmaeHtml, /id="primer-toc-heading">On this page</, 'a reference is "on this page", not "in this guide"');
+});
+
+// ---- 4. every heading is an address -------------------------------------------
+
+test('every h2, h3 and h4 gets an anchor that is a real link and copies the address', () => {
+  assert.match(drachmaeJs, /querySelectorAll\('h2\[id\], h3\[id\], h4\[id\]'\)/);
+  assert.match(drachmaeJs, /className = 'room-anchor'/);
+  assert.match(drachmaeJs, /a\.href = `#\$\{h\.id\}`/, 'the anchor is the heading\'s own id, so it works with no script');
+  assert.match(drachmaeJs, /navigator\.clipboard\.writeText\(url\)/, 'the click copies the absolute address');
+  const anchor = rule(roomCss, '.room--reference .primer-article .room-anchor');
+  assert.ok(anchor, 'the anchor has its own rule, scoped to the reference, at higher specificity than the prose link');
+  assert.match(anchor, /width:\s*24px/); assert.match(anchor, /height:\s*24px/);
+  assert.match(anchor, /text-decoration:\s*none/);
+  assert.ok(rule(roomCss, '.room--reference .primer-article :is(:target, .is-target) > .room-anchor'),
+    'the one the reader arrived at takes the accent — by :target, or by the mark the landing sets when :target resolved against nothing');
+});
+
+test('a deep link lands after the async render, the live section and the fonts', () => {
+  assert.match(drachmaeJs, /function landOnHash\(\)[\s\S]*classList\.add\('is-target'\)[\s\S]*scrollIntoView/);
+  const src = dejscomment(drachmaeJs);
+  const inserted = src.indexOf('await insertBountySection(article)');
+  const landed = src.indexOf('.then(landOnHash)');
+  assert.ok(inserted > -1 && landed > inserted, 'landOnHash runs once the rate card has taken its place, or the offsets it lands on are wrong');
+  assert.match(src, /document\.fonts\.ready[\s\S]*\.then\(landOnHash\)/, 'and after the fonts: a swap after the jump moves everything above the target');
+});
+
+test('on a phone the collapsed outline rides under the top bar, so the toggle can name the part from anywhere', () => {
+  const m = decomment(roomCss).match(/@media \(max-width: 760px\)\s*\{\s*\.room--reference \.primer-toc\s*\{([^}]*)\}/);
+  assert.ok(m, 'the reference re-sticks the contents at phone width (the archetype makes them static there)');
+  assert.match(m[1], /position:\s*sticky/);
+  assert.match(m[1], /z-index:\s*var\(--z-progress\)/, 'below the top bar in the ladder');
+});
+
+// ---- 5. the live table --------------------------------------------------------
+
+test('the live rate card is a section ahead of the closing links, not an appendix after them', () => {
+  assert.match(drachmaeJs, /CLOSING_H2 = \/\^see it\/i/);
+  assert.match(drachmaeJs, /article\.insertBefore\(section, closing\)/);
+  assert.match(drachmaeJs, /else article\.appendChild\(section\)/, 'a retitled footer falls back to appending');
+});
+
+// ---- 6. the parser, actually run ----------------------------------------------
+
+test('the shared parser reaches h4 — the six earning sources rendered as paragraphs with a literal ####', () => {
+  const MD = loadReader();
+  const { html, headings } = MD.parseMarkdown('#### 4. Achievements\n\nUnlocking one pays its bonus.\n', (h) => h);
+  assert.equal(headings.length, 1);
+  assert.equal(headings[0].level, 4);
+  assert.match(html, /<h4 id="4-achievements">4\. Achievements<\/h4>/);
+  assert.doesNotMatch(html, /####/);
+});
+
+test('a paragraph breaks before an h4 the way it breaks before an h3', () => {
+  const MD = loadReader();
+  const { html } = MD.parseMarkdown('a line\n#### A head\n', (h) => h);
+  assert.match(html, /<p>a line<\/p>\s*<h4/);
+});
+
+test('a heading that carries a link slugs by its text, so the copied address stays readable', () => {
+  const MD = loadReader();
+  const withLink = '2. Per-task credits, adjusted by *kind* ([ADR 0023](../adr/0023-kind-multipliers-and-idea-bonus.md))';
+  assert.equal(MD.slugify(withLink), MD.slugify('2. Per-task credits, adjusted by *kind* (ADR 0023)'));
+  assert.doesNotMatch(MD.slugify(withLink), /adr0023|md$/, 'the target path is not part of the address');
+});
+
+test('emphasis inside a bold run renders — the API list-price line showed its asterisks', () => {
+  const MD = loadReader();
+  const { html } = MD.parseMarkdown('- **It is the API *list* price, deliberately** and not the rest\n', (h) => h);
+  assert.match(html, /<strong>It is the API <em>list<\/em> price, deliberately<\/strong> and not the rest/);
+  const two = MD.parseMarkdown('**a** and **b**\n', (h) => h).html;
+  assert.match(two, /<strong>a<\/strong> and <strong>b<\/strong>/, 'and two bold runs on one line stay two');
+});
+
+// ---- 7. the room's h4 -----------------------------------------------------------
+
+test('the room gives the fourth level a rule, the measure and the anchor offset', () => {
+  const h4 = rule(roomCss, '.primer-article h4');
+  assert.ok(h4, 'room.css styles h4 now that the parser emits it');
+  assert.match(h4, /scroll-margin-top/, 'a deep link to an h4 clears the top bar');
+  const measured = decomment(roomCss).match(/\.primer-article\s*>\s*p,[\s\S]*?\{([^}]*)\}/);
+  assert.ok(measured, 'the measured-children list exists');
+  assert.match(measured[0], /\.primer-article\s*>\s*h4/, 'and the h4 is measured with the prose');
+});
+
+// ---- 8. the states file and the one h1 ------------------------------------------
+
+test('the states file measures the reference\'s own states, including the deep link', () => {
+  for (const name of ['read', 'toc-open', 'jump', 'out']) assert.ok(drachmaeStates.states[name], `state ${name}`);
+  assert.match(drachmaeStates.states.jump.url, /#how-karma-is-earned-and-lost$/, 'the jump lands on an h3, so the trail is what the shot proves');
+  assert.ok(drachmaeStates.reducedMotion, 'the kill switch is exercised');
+});
+
+test('the reference renders exactly one h1, the page head\'s', () => {
+  const html = dehtmlcomment(drachmaeHtml);
+  assert.equal([...html.matchAll(/<h1\b/g)].length, 1);
+  assert.match(html, /<h1 class="page-head__h">/);
+});

package/tests/idea_credit_streams_db.mjs

@@ -0,0 +1,326 @@
+// tests/idea_credit_streams_db.mjs
+//
+// task 1003000 (BV1.R176 / IC6, goal 1000067) — the ideator credit lane's three
+// streams against a REAL Postgres, so the claims IC6 makes are executable rather
+// than argued. ADR 0172; docs/governance/bongos-v1-ideator-pay-proofs.md is the
+// proof record this harness belongs to.
+//
+// WHY A DB TEST EXISTS AT ALL, when three DB-free suites already cover these
+// functions: those suites stub the client and SIMULATE `INSERT ... WHERE NOT
+// EXISTS` in JavaScript. The whole idempotency argument of the credit lane — the
+// thing that stops an author being paid twice for one idea — is therefore
+// asserted against a fake. Here the statement meets a real transaction engine,
+// real unique indexes, and the real `pms_apply_credit` trigger that moves
+// builders.total_credits. That is the only way to prove the money semantics
+// rather than restate them.
+//
+// NON-DESTRUCTIVE BY CONSTRUCTION: every fixture and every credit row is written
+// inside ONE transaction that is ALWAYS rolled back, so this is safe to point at
+// a dev database that holds real rows. It never TRUNCATEs and never commits.
+//
+// Real-DB (self-skips without Postgres; belongs in the INTEGRATION set so the
+// DB-free lane stays DB-free).
+//
+// Run:  DATABASE_URL=postgres://... node tests/idea_credit_streams_db.mjs
+//
+// PROVENANCE, stated plainly: written from the migration DDL and NOT executed by
+// its author — the machine it was written on could not run Postgres at all
+// (no docker, no psql, and an embedded server died on the Windows shared-memory
+// reserve, error 487). The first person to run it with a DATABASE_URL is the
+// first person to see it pass. Treat a failure here as a bug in this file until
+// proven otherwise, and record the outcome in the proof document above.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const credits = require('../modules/economy/credits.js');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+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}`); }
+}
+
+// The reward policy the live instance runs: builder estimate OFF, ideator lane
+// ON. Every stream below is driven through THIS, so a pass here is also the
+// ADR 0172 §2 exemption holding under the real configuration.
+const COST_PLUS_ONLY = credits.rewardPolicy({ mode: 'cost-plus-only' });
+
+// insertRow — insert into `table`, supplying `explicit` and auto-filling every
+// other NOT NULL column that has no default. Schema-driven rather than
+// hand-listed: the fixture tables (versions, tasks, idea_inbox) carry columns
+// this test does not care about, and a hand-written column list would rot the
+// first time a migration adds a NOT NULL one. Identity/serial columns are left
+// to the sequence. Returns the inserted row.
+const schemaCache = new Map();
+
+async function columnsOf(client, table) {
+  if (schemaCache.has(table)) return schemaCache.get(table);
+  const { rows } = await client.query(
+    `SELECT column_name, data_type, is_nullable, column_default, is_identity
+       FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = $1`,
+    [table]
+  );
+  schemaCache.set(table, rows);
+  return rows;
+}
+
+// `table` and the column names are interpolated rather than parameterised
+// because SQL cannot parameterise an identifier. Both are trusted by
+// construction: `table` is always a literal from this file's own fixture(), and
+// the column names come from information_schema metadata for that table — never
+// from input. Nothing here is reachable from a request.
+async function insertRow(client, table, explicit = {}) {
+  const cols = await columnsOf(client, table);
+  if (cols.length === 0) throw new Error(`table ${table} not found — is this database migrated?`);
+  const values = { ...explicit };
+  for (const c of cols) {
+    if (c.column_name in values) continue;
+    if (c.is_nullable === 'YES') continue;          // NULL is fine
+    if (c.column_default !== null) continue;        // the default covers it
+    if (c.is_identity === 'YES') continue;          // sequence owns it
+    values[c.column_name] = placeholderFor(c.data_type, c.column_name);
+  }
+  const names = Object.keys(values);
+  const params = names.map((_, i) => `$${i + 1}`);
+  const { rows } = await client.query(
+    `INSERT INTO ${table} (${names.map((n) => `"${n}"`).join(', ')})
+     VALUES (${params.join(', ')}) RETURNING *`,
+    names.map((n) => values[n])
+  );
+  return rows[0];
+}
+
+function placeholderFor(dataType, columnName) {
+  switch (dataType) {
+    case 'integer': case 'bigint': case 'smallint':
+    case 'numeric': case 'real': case 'double precision':
+      return 0;
+    case 'boolean': return false;
+    case 'timestamp with time zone': case 'timestamp without time zone': case 'date':
+      return new Date();
+    case 'json': case 'jsonb': return {};
+    case 'ARRAY': return [];
+    default: return `ic6-${columnName}`;
+  }
+}
+
+// One fully-wired idea: an author, an optional developer, a Full Idea at
+// `completeness`, and `taskCount` shipped tasks descended from it (the IC3
+// lineage stream 1 counts). Ids come from the sequences, never hardcoded.
+async function fixture(client, { completeness = 70, developed = false, taskCount = 0 } = {}) {
+  const author = await insertRow(client, 'builders', {
+    github_id: `ic6-author-${Date.now()}-${Math.random()}`,
+    github_login: 'ic6-author', display_name: 'ic6 author', total_credits: 0,
+  });
+  const developer = developed
+    ? await insertRow(client, 'builders', {
+      github_id: `ic6-dev-${Date.now()}-${Math.random()}`,
+      github_login: 'ic6-dev', display_name: 'ic6 developer', total_credits: 0,
+    })
+    : null;
+  const idea = await insertRow(client, 'idea_inbox', {
+    title: 'ic6 — a Full Idea used to prove the ideator credit lane',
+    kind: 'feature', status: 'open', captured_by: author.id,
+  });
+  await insertRow(client, 'ideas_grades', {
+    idea_id: idea.id,
+    grade: 'full',
+    completeness_score: completeness,
+    ...(developer ? { developed_by: developer.id } : {}),
+  });
+  const version = await insertRow(client, 'versions', { id: `IC6-${Date.now()}-${Math.random()}`.slice(0, 40) });
+  const tasks = [];
+  for (let i = 0; i < taskCount; i++) {
+    const task = await insertRow(client, 'tasks', {
+      version_id: version.id, title: `ic6 task ${i + 1}`, status: 'shipped',
+    });
+    await insertRow(client, 'ideas_task_lineage', {
+      task_id: task.id, idea_id: idea.id, origin: 'promote',
+    });
+    tasks.push(task);
+  }
+  return { author, developer, idea, tasks };
+}
+
+// Every ideator-lane row for ONE idea, matched on EXACT reason keys.
+//
+// The obvious spelling of this — `reason LIKE 'idea.credit.%' || ideaId || '%'` —
+// is an unanchored substring match on the id, so for idea 5 it also matches
+// `idea.credit.task_ship:15:99` and `idea.credit.full_pass:51`. Against a
+// database that already holds real ideator rows (which this file promises is
+// safe) that silently inflates the counts the assertions below turn on, which
+// is the opposite of the guarantee. So: the two per-idea keys are compared for
+// equality, and the per-task key is matched on the `<id>:` prefix — anchored by
+// the delimiter, so idea 5 can never collide with idea 15 or 51.
+async function ledger(client, ideaId) {
+  const id = String(ideaId);
+  const { rows } = await client.query(
+    `SELECT builder_id, delta, reason FROM credit_log
+      WHERE reason = 'idea.credit.full_pass:' || $1
+         OR reason = 'idea.credit.governance_pass:' || $1
+         OR reason LIKE 'idea.credit.task_ship:' || $1 || ':%'
+      ORDER BY id`,
+    [id]
+  );
+  return rows;
+}
+
+// Every test runs in its own always-rolled-back transaction.
+async function inTx(fn) {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    await fn(client);
+  } finally {
+    await client.query('ROLLBACK').catch(() => {});
+    client.release();
+  }
+}
+
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`idea_credit_streams_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  process.exit(0);
+}
+
+await test('the reward policy under test is the live one: estimate off, ideator lane on', async () => {
+  assert.equal(COST_PLUS_ONLY.perTaskCredit, false);
+  assert.equal(COST_PLUS_ONLY.ideatorCredit, true);
+});
+
+await test('stream 2 — a passing Full Idea books exactly 5, and the REAL trigger moves the balance', async () => {
+  await inTx(async (client) => {
+    const { author, idea } = await fixture(client, { completeness: 72 });
+    const r = await credits.awardIdeaFullPassCredit(client, {
+      ideaId: idea.id, authorId: author.id, completenessScore: 72, config: COST_PLUS_ONLY,
+    });
+    assert.equal(r.credited, 5);
+    const rows = await ledger(client, idea.id);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].reason, `idea.credit.full_pass:${idea.id}`);
+    // The DB-free suites cannot see this: pms_apply_credit is a real trigger.
+    const { rows: [b] } = await client.query('SELECT total_credits FROM builders WHERE id = $1', [author.id]);
+    assert.equal(Number(b.total_credits), 5, 'builders.total_credits is moved by the ledger trigger, not by the award fn');
+  });
+});
+
+await test('stream 2 — REAL SQL idempotency: three calls, one row, one payment', async () => {
+  await inTx(async (client) => {
+    const { author, idea } = await fixture(client, { completeness: 72 });
+    const args = { ideaId: idea.id, authorId: author.id, completenessScore: 72, config: COST_PLUS_ONLY };
+    const first = await credits.awardIdeaFullPassCredit(client, args);
+    const second = await credits.awardIdeaFullPassCredit(client, args);
+    const third = await credits.awardIdeaFullPassCredit(client, args);
+    assert.equal(first.credited, 5);
+    assert.equal(second.credited, 0);
+    assert.equal(second.reason, 'already_paid');
+    assert.equal(third.credited, 0);
+    assert.equal((await ledger(client, idea.id)).length, 1, 'WHERE NOT EXISTS held against a real engine');
+    const { rows: [b] } = await client.query('SELECT total_credits FROM builders WHERE id = $1', [author.id]);
+    assert.equal(Number(b.total_credits), 5, 'no double-pay reached the balance either');
+  });
+});
+
+await test('stream 1 — each shipped task under the idea pays, grade-scaled, once per task', async () => {
+  await inTx(async (client) => {
+    const { author, idea, tasks } = await fixture(client, { completeness: 80, taskCount: 3 });
+    let total = 0;
+    for (const t of tasks) {
+      const r = await credits.awardIdeaTaskShipCredit(client, { taskId: t.id, config: COST_PLUS_ONLY });
+      assert.equal(r.reason, 'paid', `task ${t.id} should pay`);
+      total += r.credited;
+    }
+    // round(5 × 80/100) = 4, three times.
+    assert.equal(total, 12);
+    // Re-driving every one pays nothing more.
+    for (const t of tasks) {
+      const again = await credits.awardIdeaTaskShipCredit(client, { taskId: t.id, config: COST_PLUS_ONLY });
+      assert.equal(again.credited, 0);
+      assert.equal(again.reason, 'already_paid');
+    }
+    const { rows: [b] } = await client.query('SELECT total_credits FROM builders WHERE id = $1', [author.id]);
+    assert.equal(Number(b.total_credits), 12, 'one idea, many tasks — paid per task, never twice');
+  });
+});
+
+await test('stream 3 — a board-ratified Full Idea books its completeness percent, once per idea', async () => {
+  await inTx(async (client) => {
+    const { author, idea } = await fixture(client, { completeness: 70 });
+    const args = { ideaId: idea.id, authorId: author.id, completenessScore: 70, config: COST_PLUS_ONLY };
+    const r = await credits.awardIdeaGovernancePassCredit(client, args);
+    assert.equal(r.credited, 70, "the owner's worked example: 70%-complete + passes = 70");
+    const again = await credits.awardIdeaGovernancePassCredit(client, args);
+    assert.equal(again.credited, 0);
+    assert.equal(again.reason, 'already_paid');
+    const rows = await ledger(client, idea.id);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].reason, `idea.credit.governance_pass:${idea.id}`);
+  });
+});
+
+await test('stream 3 — a constitutional amendment books nothing', async () => {
+  await inTx(async (client) => {
+    const { author, idea } = await fixture(client, { completeness: 90 });
+    const r = await credits.awardIdeaGovernancePassCredit(client, {
+      ideaId: idea.id, authorId: author.id, completenessScore: 90,
+      subjectType: 'constitutional_amendment', config: COST_PLUS_ONLY,
+    });
+    assert.equal(r.credited, 0);
+    assert.equal(r.reason, 'not_a_full_idea');
+    assert.equal((await ledger(client, idea.id)).length, 0);
+  });
+});
+
+await test('the spark split is real rows: 70/30 under ONE reason key, total conserved', async () => {
+  await inTx(async (client) => {
+    const { author, developer, idea } = await fixture(client, { completeness: 70, developed: true });
+    const r = await credits.awardIdeaGovernancePassCredit(client, {
+      ideaId: idea.id, authorId: author.id, completenessScore: 70, config: COST_PLUS_ONLY,
+    });
+    assert.equal(r.credited, 70);
+    const rows = await ledger(client, idea.id);
+    assert.equal(rows.length, 2, 'two payees, one reason — the builder-scoped predicate is load-bearing here');
+    assert.equal(rows[0].reason, rows[1].reason);
+    const byBuilder = new Map(rows.map((x) => [String(x.builder_id), Number(x.delta)]));
+    assert.equal(byBuilder.get(String(developer.id)), 49, '70% of 70, rounded');
+    assert.equal(byBuilder.get(String(author.id)), 21, 'the remainder — never independently rounded');
+  });
+});
+
+await test('all three streams coexist on one idea without double-paying', async () => {
+  await inTx(async (client) => {
+    const { author, idea, tasks } = await fixture(client, { completeness: 70, taskCount: 1 });
+    await credits.awardIdeaFullPassCredit(client, { ideaId: idea.id, authorId: author.id, completenessScore: 70, config: COST_PLUS_ONLY });
+    await credits.awardIdeaTaskShipCredit(client, { taskId: tasks[0].id, config: COST_PLUS_ONLY });
+    await credits.awardIdeaGovernancePassCredit(client, { ideaId: idea.id, authorId: author.id, completenessScore: 70, config: COST_PLUS_ONLY });
+    const rows = await ledger(client, idea.id);
+    const reasons = rows.map((r) => r.reason.split(':')[0]).sort();
+    assert.deepEqual([...new Set(reasons)], ['idea.credit.full_pass', 'idea.credit.governance_pass', 'idea.credit.task_ship']);
+    // 5 (grade) + round(5 × 0.7) = 4 (one shipped task) + 70 (ratification) = 79
+    const { rows: [b] } = await client.query('SELECT total_credits FROM builders WHERE id = $1', [author.id]);
+    assert.equal(Number(b.total_credits), 79, 'three distinct reasons, three distinct payments, no overlap');
+  });
+});
+
+// DELIBERATELY NOT ASSERTED HERE: claim 6, that the retired ADR 0023 slice no
+// longer fires alongside stream 1. The tempting test — call
+// awardIdeaTaskShipCredit, then check no `idea_promotion_bonus` row appeared —
+// is a TAUTOLOGY: that function contains no code path that could write that
+// reason, so the assertion passes without touching the thing claim 6 is about,
+// which is the CALL SITE in modules/lifecycle/db-ship.js. Driving the real
+// awardLandingCredit needs a claim/session fixture well beyond this harness, so
+// claim 6's evidence stays the static read recorded in the proof document
+// (db-ship.js:236 calls stream 1 and nothing else, and no ship path calls the
+// slice). A test that cannot fail is worse than no test: it reads as coverage.
+
+console.log(`\nidea_credit_streams_db: ${passed} passed, ${failed} failed`);
+await pool.end();
+if (failed > 0) process.exit(1);