@bongos/core 1.18.3 → 1.18.18

package/tests/confirm_attribution.mjs

@@ -1,18 +1,22 @@
 // tests/confirm_attribution.mjs
 //
-// Regression guard for #661 — when an Archon manual-confirms (POST
-// /tasks/:id/confirm) ANOTHER builder's completed task, BOTH the credit_log
-// row AND tasks.shipped_by must land with the CLAIM HOLDER (the builder who
-// did the work), never the confirming Archon.
+// Regression guard for #661 + ADR 0120 (pay-on-land).
 //
-// Before #661, confirmTask({ taskId, builderId }) used `builderId` (the
-// confirmer, = req.builder.id, the Archon) for both the credit and the
-// shipped_by COALESCE. Live repro 2026-06-04: Xenos (#25) shipped #660 from
-// Windows, the grader infra-errored so it stalled at `completed`, an Archon
-// (#1) manual-confirmed, and the 15c landed on #1 instead of #25. The fix
-// resolves the most-recent claim holder up front and threads it into both the
-// tasks UPDATE and the credit insert; it falls back to the confirmer only when
-// the task has no claim at all.
+// #661: when an Archon manual-confirms (POST /tasks/:id/confirm) ANOTHER
+// builder's completed task, tasks.shipped_by must land with the CLAIM HOLDER
+// (the builder who did the work), never the confirming Archon. Live repro
+// 2026-06-04: Xenos (#25) shipped #660, the grader infra-errored so it stalled
+// at `completed`, an Archon (#1) manual-confirmed, and shipped_by must still be
+// #25. confirmTask resolves the most-recent claim holder up front and threads
+// it into the tasks UPDATE; it falls back to the confirmer only when the task
+// has no claim at all.
+//
+// ADR 0120: confirm NO LONGER awards the per-task credit. The credit + idea
+// bonus now land at the confirmed→shipped flip (shipTask → awardLandingCredit,
+// reason='task.shipped'); a task that strands at 'confirmed' pays nothing until
+// its code is on `main`. So confirm must run ZERO credit_log INSERTs and return
+// creditsAwarded === 0 — but it must STILL attribute shipped_by to the claim
+// holder. The credit-at-ship half is pinned by tests/pay_on_land.mjs.
 //
 // confirmTask opens its own transaction via pool.connect(); the #538 `deps.pool`
 // injection seam (honored ONLY when NODE_ENV==='test') lets us drive it with a
@@ -27,16 +31,13 @@ import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
 process.env.NODE_ENV = 'test';
 
 const require = createRequire(import.meta.url);
-// Credit allocation carved into modules/economy/ (BV1.R77 / ADR 0093 §1-2):
-// confirmTask resolves the `reward` kernel port for the credit grant, so the
-// port must be registered before driving it. reward.js delegates to the live
-// achievements/credits objects (stubs would bite if used; confirmTask uses only
-// the credit path).
+// confirmTask resolves the `reward` kernel port for the achievement reconcile
+// (the credit path moved to ship), so the port must be registered before
+// driving it. Stub the achievement hooks to no-ops.
 const achievements = require('../modules/economy/achievements.js');
 achievements.evaluateAfterShip = async () => [];
 achievements.evaluateAfterCreditAward = async () => [];
 achievements.evaluateAfterClaim = async () => [];
-// task 1679: confirmTask (the skip-grade path) now reconciles achievements.
 achievements.reconcileBuilderAchievements = async () => [];
 const seams = require('../src/module-seams.js');
 if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
@@ -48,10 +49,9 @@ const { test, summary } = makeRunner();
 // SQL-aware fake: returns rows by matching the statement, records every call so
 // the test can inspect the exact params each query received. Order-independent.
 //   claimHolderId === null  → simulate a task with NO claims row (fallback path)
-//   priorCredit === true    → a 'task.confirmed' row already exists (idempotent)
 //   taskCompleted === false → the tasks UPDATE matches nothing (wrong state)
-function fakePool({ claimHolderId, task, priorCredit = false, taskCompleted = true }) {
-  return makeSqlAwareClient((s, params) => {
+function fakePool({ claimHolderId, task, taskCompleted = true }) {
+  return makeSqlAwareClient((s) => {
       if (/SELECT builder_id FROM claims/.test(s)) {
         return { rows: claimHolderId == null ? [] : [{ builder_id: claimHolderId }] };
       }
@@ -62,13 +62,7 @@ function fakePool({ claimHolderId, task, priorCredit = false, taskCompleted = tr
             : [],
         };
       }
-      if (/SELECT 1 FROM credit_log .* 'task\.confirmed'/.test(s)) {
-        return { rows: priorCredit ? [{ '?column?': 1 }] : [] };
-      }
-      if (/SELECT 1 FROM credit_log .* 'idea_promotion_bonus'/.test(s)) return { rows: [] };
-      if (/FROM idea_inbox/.test(s)) return { rows: [] };   // no idea lineage
-      if (/INSERT INTO credit_log/.test(s)) return { rows: [] };
-      return { rows: [] };                                  // BEGIN / COMMIT / etc.
+      return { rows: [] };                                  // BEGIN / COMMIT / SAVEPOINT / etc.
   });
 }
 
@@ -82,19 +76,15 @@ const WORKER = 25;      // the claim holder who actually did the work
 const TASK = { id: 660, title: 'fixture task', credits_reward: 15, kind: 'feature' };
 
 // =========================================================================
-await test('confirm: credit_log.builder_id is the CLAIM HOLDER, not the confirming Archon', async () => {
+await test('confirm: pay-on-land — NO credit awarded at confirm, but shipped_by is the claim holder', async () => {
   const pool = fakePool({ claimHolderId: WORKER, task: TASK });
   const out = await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
 
   assert.equal(out.taskStatus, 'confirmed', 'task should flip to confirmed');
   assert.equal(out.creditedBuilderId, WORKER, 'creditedBuilderId must be the claim holder');
-  assert.ok(out.creditsAwarded > 0, 'a positive credit must be awarded');
-
-  const credit = find(pool._client.queries, /INSERT INTO credit_log/);
-  assert.ok(credit, 'a credit_log INSERT must run');
-  assert.equal(credit.params[0], WORKER, 'credit_log.builder_id must be the claim holder');
-  assert.notEqual(credit.params[0], ARCHON, 'credit_log.builder_id must NOT be the Archon');
-  assert.equal(credit.params[1], TASK.id, 'credit_log.task_id must be the task');
+  assert.equal(out.creditsAwarded, 0, 'ADR 0120: no per-task credit lands at confirm');
+  assert.equal(all(pool._client.queries, /INSERT INTO credit_log/).length, 0,
+    'confirm must run ZERO credit_log INSERTs — the reward waits for the land');
 });
 
 await test('confirm: tasks.shipped_by ($2 of the UPDATE) is attributed to the claim holder', async () => {
@@ -117,19 +107,13 @@ await test('confirm: the claim-holder lookup happens BEFORE the tasks UPDATE', a
   assert.ok(idxClaim < idxUpdate, 'claim holder must be resolved before the tasks UPDATE binds shipped_by');
 });
 
-await test('confirm: NO claim on the task → falls back to the confirmer (never refuses a legit confirm)', async () => {
+await test('confirm: NO claim on the task → shipped_by falls back to the confirmer (never refuses a legit confirm)', async () => {
   const pool = fakePool({ claimHolderId: null, task: TASK });
   const out = await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
   assert.equal(out.creditedBuilderId, ARCHON, 'with no claim, the confirmer is the only candidate');
-  const credit = find(pool._client.queries, /INSERT INTO credit_log/);
-  assert.equal(credit.params[0], ARCHON, 'fallback credit goes to the confirmer');
-});
-
-await test('confirm: idempotent — a prior task.confirmed credit means no second credit insert', async () => {
-  const pool = fakePool({ claimHolderId: WORKER, task: TASK, priorCredit: true });
-  const out = await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
-  assert.equal(out.creditsAwarded, 0, 'no fresh credit on a re-confirm');
-  assert.equal(all(pool._client.queries, /INSERT INTO credit_log/).length, 0, 'must not double-insert credit');
+  const taskUpdate = find(pool._client.queries, /^UPDATE tasks/);
+  assert.equal(taskUpdate.params[1], ARCHON, 'shipped_by binds to the confirmer when there is no claim');
+  assert.equal(all(pool._client.queries, /INSERT INTO credit_log/).length, 0, 'still no credit at confirm');
 });
 
 await test('confirm: transaction commits on the happy path (no rollback)', async () => {

package/tests/credit_grant.mjs

@@ -31,6 +31,9 @@ const {
   computeSessionTokenReward,
   awardSessionTokenReward,
   REWARD_MARGIN_PCT,
+  REWARD_MODE_DEFAULT,
+  REWARD_MODE_COST_PLUS_ONLY,
+  rewardPolicy,
 } = require('../modules/economy/credits.js');
 
 const { test, summary } = makeRunner();
@@ -139,9 +142,17 @@ await test('insertMultipliedConfirmCredit: feature pays exactly raw', async () =
   assert.equal(res.raw, 40);
   assert.equal(client.queries.length, 1);
   assert.match(client.queries[0].sql, /INSERT INTO credit_log/);
-  assert.match(client.queries[0].sql, /'task\.confirmed'/);
-  // params: [builderId, taskId, delta, description]
-  assert.deepEqual(client.queries[0].params, [1, 100, 40, '40c × 1.0 = 40c (feature)']);
+  // ADR 0120: reason is now a BOUND PARAM (default 'task.confirmed'), not a SQL
+  // literal, so the pay-on-land move can book 'task.shipped' at the land.
+  // params: [builderId, taskId, delta, reason, description]
+  assert.deepEqual(client.queries[0].params, [1, 100, 40, 'task.confirmed', '40c × 1.0 = 40c (feature)']);
+});
+
+await test('insertMultipliedConfirmCredit: reason param books task.shipped (ADR 0120 pay-on-land)', async () => {
+  const client = fakeClient();
+  await insertMultipliedConfirmCredit(client, 1, 100, 40, 'feature', 'task.shipped');
+  assert.equal(client.queries[0].params[3], 'task.shipped', 'reason param must reach credit_log.reason');
+  assert.equal(client.queries[0].params[4], '40c × 1.0 = 40c (feature)', 'description follows reason');
 });
 
 await test('insertMultipliedConfirmCredit: learning-capture pays 1.5×', async () => {
@@ -149,7 +160,7 @@ await test('insertMultipliedConfirmCredit: learning-capture pays 1.5×', async (
   const res = await insertMultipliedConfirmCredit(client, 1, 100, 40, 'learning-capture');
   assert.equal(res.creditsAwarded, 60);
   assert.equal(client.queries[0].params[2], 60);
-  assert.equal(client.queries[0].params[3], '40c × 1.5 = 60c (learning-capture)');
+  assert.equal(client.queries[0].params[4], '40c × 1.5 = 60c (learning-capture)');
 });
 
 await test('insertMultipliedConfirmCredit: cleanup pays 0.8×', async () => {
@@ -273,9 +284,14 @@ await test('computeSessionTokenReward: $1.65 × 1.20 = 2 drachmae ($1=1 drachma)
   assert.equal(computeSessionTokenReward(100).drachmae, 120, '$100 × 1.20 = 120 drachmae ≈ dollars');
 });
 
+// The watermark SELECT's row shape (task 1002474). `paid` = drachmae already booked
+// for this session; `legacy` = rows predating the top-up column (reward_basis = 0).
+const ledger = (paid = 0, legacy = 0) => [{ paid, legacy }];
+const NO_PRIOR = ledger(0, 0);
+
 await test('awardSessionTokenReward: prices opus tokens server-side + inserts ONE credit_log row', async () => {
   const client = fakeClient();
-  client.enqueue([]);          // idempotency SELECT → no prior row
+  client.enqueue(NO_PRIOR);    // watermark SELECT → nothing paid yet
   client.enqueue([{ id: 1 }]); // INSERT ... RETURNING id
   const res = await awardSessionTokenReward(client, 7, 'sess-abc', {
     'claude-opus-4-8': { input: 110_000 }, // 110k × $5/M = $0.55 (Opus 4.8, task 1343)
@@ -286,14 +302,16 @@ await test('awardSessionTokenReward: prices opus tokens server-side + inserts ON
   const insert = client.queries[1];
   assert.match(insert.sql, /INSERT INTO credit_log/);
   assert.match(insert.sql, /session\.token_reward/);
+  // params gained reward_basis (the cumulative owed total) as the last positional.
   assert.deepEqual(insert.params, [
-    7, 1, '$0.55 true cost × 1.20 = 1 drachmae (token reward)', 'sess-abc',
+    7, 1, '$0.55 true cost × 1.20 = 1 drachmae (token reward)', 'sess-abc', 1,
   ]);
 });
 
-await test('awardSessionTokenReward: idempotent — prior row → no INSERT, no double payout', async () => {
+await test('awardSessionTokenReward: idempotent — nothing further owed → no INSERT, no double payout', async () => {
   const client = fakeClient();
-  client.enqueue([{}]); // SELECT finds a prior reward row for this session
+  // The session already collected everything it is owed at this cost level.
+  client.enqueue(ledger(1, 0));
   const res = await awardSessionTokenReward(client, 7, 'sess-abc', {
     'claude-opus-4-8': { input: 110_000 },
   });
@@ -304,7 +322,7 @@ await test('awardSessionTokenReward: idempotent — prior row → no INSERT, no
 
 await test('awardSessionTokenReward: ON CONFLICT race → INSERT returns no row → clean no-op', async () => {
   const client = fakeClient();
-  client.enqueue([]); // SELECT → no prior
+  client.enqueue(NO_PRIOR);
   client.enqueue([]); // INSERT swallowed by ON CONFLICT DO NOTHING (RETURNING empty)
   const res = await awardSessionTokenReward(client, 7, 'sess-x', {
     'claude-opus-4-8': { input: 110_000 },
@@ -315,7 +333,7 @@ await test('awardSessionTokenReward: ON CONFLICT race → INSERT returns no row
 
 await test('awardSessionTokenReward: unknown model still pays (opus rate) + flags unknownModels', async () => {
   const client = fakeClient();
-  client.enqueue([]);
+  client.enqueue(NO_PRIOR);
   client.enqueue([{ id: 2 }]);
   const res = await awardSessionTokenReward(client, 7, 'sess-u', { 'gpt-4o': { input: 1_000_000 } });
   assert.equal(res.awarded, true);
@@ -323,6 +341,100 @@ await test('awardSessionTokenReward: unknown model still pays (opus rate) + flag
   assert.ok(res.unknownModels.includes('gpt-4o'));
 });
 
+// =========================================================================
+// task 1002474 — a multi-ship session must be paid for ALL of its cost.
+//
+// The reward was a hard no-op once ANY row existed for the session_id, so a
+// session that shipped a second task was paid only for the cost it had accrued
+// at its FIRST ship. Measured: three ships from one session priced at $14.30 /
+// $27.76 / $40.32 paid 17 drachmae total, where the full session was worth 48 —
+// about 65% of real shipped work unrewarded. Multi-ship sessions are normal
+// (one claim at a time, but ship → new worktree → claim again).
+//
+// The cure is watermark accounting: book the DIFFERENCE between what the whole
+// session is now worth and what it has already been paid.
+// =========================================================================
+
+await test('1002474 a later, more expensive ship books only the INCREMENT', async () => {
+  const client = fakeClient();
+  client.enqueue(ledger(6, 0));  // already paid 6 for this session
+  client.enqueue([{ id: 9 }]);
+  // $20 of opus input = 4M tokens × $5/M → 20 × 1.20 = 24 owed in total.
+  const res = await awardSessionTokenReward(client, 7, 'sess-multi', {
+    'claude-opus-4-8': { input: 4_000_000 },
+  });
+  assert.equal(res.awarded, true);
+  assert.equal(res.drachmae, 18, '24 owed − 6 already paid = 18, not a second full 24');
+  const insert = client.queries[1];
+  assert.equal(insert.params[1], 18, 'the ledger row carries the INCREMENT');
+  assert.equal(insert.params[4], 24, 'reward_basis is the CUMULATIVE owed total');
+  assert.match(insert.params[2], /top-up/i, 'the audit string must show this is a top-up');
+});
+
+await test('1002474 the running total never exceeds the full-session value', async () => {
+  // Three ships of one session, exactly the shape that was measured.
+  const usageFor = (dollars) => ({ 'claude-opus-4-8': { input: (dollars / 5) * 1_000_000 } });
+  let paid = 0;
+  for (const dollars of [14.30, 27.76, 40.32]) {
+    const client = fakeClient();
+    client.enqueue(ledger(paid, 0));
+    client.enqueue([{ id: 1 }]);
+    const res = await awardSessionTokenReward(client, 7, 'sess-3ship', usageFor(dollars));
+    paid += res.drachmae;
+  }
+  assert.equal(paid, Math.round(40.32 * 1.2), 'the session ends up paid its full cost-plus value');
+  assert.equal(paid, 48);
+});
+
+await test('1002474 a cheaper re-upload never claws back or pays again', async () => {
+  const client = fakeClient();
+  client.enqueue(ledger(48, 0)); // already fully paid at the $40.32 level
+  const res = await awardSessionTokenReward(client, 7, 'sess-3ship', {
+    'claude-opus-4-8': { input: 1_000_000 }, // a stale/smaller digest → owes 6
+  });
+  assert.equal(res.awarded, false, 'owed − paid is negative → nothing happens');
+  assert.equal(res.drachmae, 0, 'never a negative credit_log row');
+  assert.equal(client.queries.length, 1, 'no INSERT at all');
+});
+
+await test('1002474 a LEGACY session (pre-migration row) is left alone for the backfill to decide', async () => {
+  const client = fakeClient();
+  // reward_basis = 0 marks a row booked before this change. Topping it up would be
+  // an uncontrolled retroactive payout; the backfill (task 1002448) owns that call.
+  client.enqueue(ledger(17, 1));
+  const res = await awardSessionTokenReward(client, 7, 'sess-legacy', {
+    'claude-opus-4-8': { input: 8_000_000 }, // would otherwise owe far more
+  });
+  assert.equal(res.awarded, false, 'no surprise retroactive payout on deploy');
+  assert.equal(res.drachmae, 0);
+  assert.equal(res.settled, 'legacy', 'and it says WHY, so this is diagnosable');
+  assert.equal(client.queries.length, 1, 'no INSERT');
+});
+
+await test('1002474 a single-ship session pays exactly what it paid before (no regression)', async () => {
+  const client = fakeClient();
+  client.enqueue(NO_PRIOR);
+  client.enqueue([{ id: 3 }]);
+  const res = await awardSessionTokenReward(client, 7, 'sess-single', {
+    'claude-opus-4-8': { input: 4_000_000 }, // $20 → 24
+  });
+  assert.equal(res.awarded, true);
+  assert.equal(res.drachmae, 24);
+  assert.equal(client.queries[1].params[1], 24, 'first payment is the whole amount, unchanged');
+  assert.doesNotMatch(client.queries[1].params[2], /top-up/i, 'a first payment is not labelled a top-up');
+});
+
+await test('1002474 the INSERT still carries a DB-level double-pay backstop', async () => {
+  const client = fakeClient();
+  client.enqueue(NO_PRIOR);
+  client.enqueue([{ id: 4 }]);
+  await awardSessionTokenReward(client, 7, 'sess-guard', { 'claude-opus-4-8': { input: 4_000_000 } });
+  const insert = client.queries[1];
+  assert.match(insert.sql, /ON CONFLICT/, 'the race guard must survive the rewrite');
+  assert.match(insert.sql, /DO NOTHING/);
+  assert.match(insert.sql, /reward_basis/, 'and it must be keyed on (session_id, reward_basis)');
+});
+
 // task 1676 — the cost-plus zero-out fix for the dev-box/CI agent ship path.
 // Symptom (ADR 0097): those sessions uploaded empty/unpriceable model_usage, so
 // priceModelUsage returned $0 and the reward rounded to 0 — even though real
@@ -370,6 +482,82 @@ await test('REWARD_MARGIN_PCT exported as 20', () => {
   assert.equal(REWARD_MARGIN_PCT, 20);
 });
 
+// =========================================================================
+// (5) reward MODE — cost-plus-only vs cost-plus-and-estimate (task 1002270,
+//     ADR 0146). rewardPolicy() maps a raw branding.reward object → the
+//     effective policy (pure, so no branding()-cache juggling); the derived
+//     perTaskCredit boolean is what insertMultipliedConfirmCredit gates the
+//     per-task ESTIMATE payout on. The cost-plus session reward is untouched.
+// =========================================================================
+
+await test('rewardPolicy: default (no mode) → pay both streams; margin/peg resolve', () => {
+  const p = rewardPolicy({});
+  assert.equal(p.mode, REWARD_MODE_DEFAULT);
+  assert.equal(p.perTaskCredit, true, 'a default instance pays the per-task estimate');
+  assert.equal(p.marginPct, 20);
+  assert.equal(p.usdPeg, 1);
+});
+
+await test('rewardPolicy: mode "cost-plus-only" → per-task estimate payout OFF, cost-plus untouched', () => {
+  const p = rewardPolicy({ mode: 'cost-plus-only', marginPct: 20, usdPeg: 1 });
+  assert.equal(p.mode, REWARD_MODE_COST_PLUS_ONLY);
+  assert.equal(p.perTaskCredit, false, 'cost-plus-only suppresses the per-task estimate payout');
+  assert.equal(p.marginPct, 20, 'the cost-plus margin is unaffected — that stream is still paid');
+  assert.equal(p.usdPeg, 1);
+});
+
+await test('rewardPolicy: unknown/garbage mode → default (a typo never silently zeroes rewards)', () => {
+  for (const bad of ['costplus', 'COST-PLUS-ONLY', 'only', '', null, undefined, 42]) {
+    const p = rewardPolicy({ mode: bad });
+    assert.equal(p.perTaskCredit, true, `garbage mode ${JSON.stringify(bad)} must default to paying`);
+    assert.equal(p.mode, REWARD_MODE_DEFAULT);
+  }
+  assert.equal(rewardPolicy(null).perTaskCredit, true, 'a missing reward object → default');
+  assert.equal(rewardPolicy(undefined).perTaskCredit, true);
+});
+
+await test('rewardPolicy: cost-plus-only still honors a custom margin + peg', () => {
+  const p = rewardPolicy({ mode: 'cost-plus-only', marginPct: 35, usdPeg: 2 });
+  assert.equal(p.perTaskCredit, false);
+  assert.equal(p.marginPct, 35);
+  assert.equal(p.usdPeg, 2);
+});
+
+await test('insertMultipliedConfirmCredit: cost-plus-only mode writes NO credit_log row', async () => {
+  const client = fakeClient();
+  const res = await insertMultipliedConfirmCredit(
+    client, 7, 100, 60, 'feature', 'task.shipped', { perTaskCredit: false }
+  );
+  assert.equal(res.creditsAwarded, 0, 'no per-task estimate credit paid');
+  assert.equal(res.skipped, REWARD_MODE_COST_PLUS_ONLY, 'reports why it was skipped');
+  assert.equal(client.queries.length, 0, 'no INSERT (nor SELECT) — the estimate payout is fully suppressed');
+  assert.equal(res.raw, 60, 'raw + multiplier still reported for the audit shape');
+  assert.equal(res.multiplier, KIND_MULTIPLIERS.feature);
+});
+
+await test('insertMultipliedConfirmCredit: default/both mode still writes the row (behavior preserved)', async () => {
+  const client = fakeClient();
+  client.enqueue([{ id: 1 }]); // the INSERT
+  const res = await insertMultipliedConfirmCredit(
+    client, 7, 100, 60, 'feature', 'task.shipped', { perTaskCredit: true }
+  );
+  assert.equal(res.creditsAwarded, 60, '60 × 1.0 (feature) still paid when both streams are on');
+  assert.equal(client.queries.length, 1, 'the credit_log INSERT runs');
+  assert.match(client.queries[0].sql, /INSERT INTO credit_log/);
+  assert.equal(client.queries[0].params[3], 'task.shipped', 'booked under the pay-on-land reason');
+});
+
+await test('cost-plus-only cascade: a 0 per-task credit → idea-promotion slice is 0 (no bonus row)', async () => {
+  // In cost-plus-only mode the lifecycle's awardLandingCredit passes the (now 0)
+  // creditsAwarded into maybeAwardIdeaPromotionBonus, whose 25% slice of the
+  // unpaid estimate must therefore also be 0 — no lineage lookup, no bonus row.
+  // This mirrors the live lifecycle cascade without importing that module.
+  const client = fakeClient();
+  const res = await maybeAwardIdeaPromotionBonus(client, 100, 1, 0);
+  assert.equal(res.ideaBonusAwarded, 0);
+  assert.equal(client.queries.length, 0, 'no lineage lookup, no bonus INSERT when the base credit is 0');
+});
+
 // -------------------------------------------------------------------------
 // runner summary
 // -------------------------------------------------------------------------