@bongos/core 1.19.296 → 1.19.298

package/tests/idea_develop_spark.mjs

@@ -0,0 +1,436 @@
+// tests/idea_develop_spark.mjs
+//
+// task 1002922 (BV1.R146, goal 1000062) — develop a Spark into a Full Idea,
+// preserving attribution.
+//
+// The done-when, as assertions: the row keeps its ID and its ORIGINAL AUTHOR; a
+// DISTINCT DEVELOPER is recorded; references to the idea never break (nothing
+// writes idea_inbox); and a spark can be developed ONLY ONCE — enforced in the
+// UPDATE predicate, not by a read-then-write that loses the race.
+//
+// It also pins the scope boundary that matters for money: this path must NOT pay
+// the stream-2 "Full Idea passed" credit. awardIdeaFullPassCredit is idempotent
+// per (builder, idea), so paying the DEVELOPER here would not block a later
+// payment to the AUTHOR — one idea would pay twice. R147 owns the split.
+//
+// DB-free the idea_full_capture.mjs way: pool.query patched on the doorway before
+// the modules load, so the REAL SQL is captured and the REAL handler runs.
+//
+// Run:  node tests/idea_develop_spark.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+let queries = [];
+let idea = null;
+let developRows = [];      // what the guarded UPDATE returns ([] = guard fired)
+
+api.pool.query = async (sql, params = []) => {
+  queries.push({ sql, params });
+  if (/UPDATE ideas_grades/i.test(sql)) return { rows: developRows };
+  if (/FROM idea_inbox/i.test(sql)) return { rows: idea ? [idea] : [] };
+  return { rows: [] };
+};
+
+// Which ports the handler asked the kernel for — the credit boundary is asserted
+// by the ABSENCE of 'reward' here, which is stronger than checking for no INSERT.
+let portsResolved = [];
+const realResolveOptional = api.resolveOptional;
+api.resolveOptional = (name) => { portsResolved.push(name); return undefined; };
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const routesFactory = require('../modules/ideas/routes/inbox.js');
+const router = routesFactory({});
+
+function handlerFor(pathStr, method) {
+  const layer = router.stack.find((l) => l.route && l.route.path === pathStr && l.route.methods[method]);
+  assert.ok(layer, `route ${method.toUpperCase()} ${pathStr} is not mounted`);
+  const stack = layer.route.stack.map((s) => s.handle);
+  return stack[stack.length - 1];
+}
+const postDevelop = handlerFor('/inbox/:id/develop', 'post');
+
+const FULL = Object.fromEntries(
+  BASE_TEMPLATE.fields.map((f) => [f.key, `A substantive answer for ${f.key}, long enough to clear the floor.`]),
+);
+
+function call({ body = { field_values: FULL }, builderId = '42' } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = { params: { id: '77' }, body, query: {}, builder: { id: builderId, rank: 'xenos' } };
+    const res = {
+      statusCode: 200,
+      status(c) { this.statusCode = c; return this; },
+      json(payload) { resolve({ status: this.statusCode, payload }); },
+      // Production nests res.fail's third argument under error.details (ADR 0116).
+      // Kept BOTH here: `details` verbatim (so an ARRAY of field errors survives —
+      // spreading one yields {0:…} and silently loses the shape), plus the object
+      // spread the sibling idea tests read.
+      fail(code, status, extra) {
+        const s = typeof status === 'number' ? status : (status && status.status) || 500;
+        const spread = extra && !Array.isArray(extra) ? extra : {};
+        resolve({ status: s, payload: { error: code, details: extra, ...spread } });
+      },
+    };
+    Promise.resolve(postDevelop(req, res, (err) => reject(err || new Error('next() called')))).catch(reject);
+  });
+}
+
+const updateQ = () => queries.find((q) => /UPDATE ideas_grades/i.test(q.sql));
+const writes = () => queries.filter((q) => /^\s*(UPDATE|INSERT|DELETE)/i.test(q.sql));
+
+let passed = 0;
+let failed = 0;
+const basePoolQuery = async (sql, params = []) => {
+  queries.push({ sql, params });
+  if (/UPDATE ideas_grades/i.test(sql)) return { rows: developRows };
+  if (/FROM idea_inbox/i.test(sql)) return { rows: idea ? [idea] : [] };
+  return { rows: [] };
+};
+
+async function test(name, fn) {
+  queries = [];
+  portsResolved = [];
+  // Restored every test: cases below swap in a two-phase pool stub (a triager
+  // closing the idea mid-request) and reward/government port stubs, and none of
+  // them may leak into the next test.
+  api.pool.query = basePoolQuery;
+  api.resolveOptional = (name) => { portsResolved.push(name); return undefined; };
+  // The author is builder 9; the developer in call() defaults to 42.
+  idea = {
+    id: '77', title: 'a spark', body_md: 'the thought', status: 'open',
+    captured_by: '9', captured_at: '2026-08-01T00:00:00Z',
+    grade: 'spark', template_key: null, field_values: null,
+    completeness_score: null, developed_by: null, developed_at: null,
+  };
+  developRows = [{
+    idea_id: '77', grade: 'full', template_key: 'base-v1', field_values: FULL,
+    completeness_score: 100, developed_by: '42', developed_at: '2026-08-22T12:00:00Z',
+  }];
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- the happy path, and what it preserves ------------------------------
+
+await test('ANY builder can develop a spark — cross-builder pickup is the point', async () => {
+  const r = await call();
+  assert.equal(r.status, 200);
+  assert.equal(r.payload.developed, true);
+  assert.equal(r.payload.idea.grade, 'full');
+  assert.equal(r.payload.idea.completeness_score, 100);
+});
+
+await test('the row keeps its ID and its ORIGINAL author; only the grade moves', async () => {
+  const r = await call();
+  assert.equal(r.payload.idea.id, '77', 'same id — references never break');
+  assert.equal(r.payload.idea.captured_by, '9', 'the author is NOT overwritten');
+  assert.equal(r.payload.idea.captured_at, '2026-08-01T00:00:00Z', 'nor the capture time');
+  // The strongest form of "references never break": idea_inbox is never WRITTEN.
+  // Matched on the write verb + table, not the bare table name — the status guard
+  // legitimately READS idea_inbox in an EXISTS subquery inside the grade UPDATE.
+  assert.ok(
+    !queries.some((q) => /(UPDATE\s+idea_inbox|INSERT\s+INTO\s+idea_inbox|DELETE\s+FROM\s+idea_inbox)/i.test(q.sql)),
+    'development touches ideas_grades only — no new row, no idea_inbox mutation',
+  );
+  // And the write really is to the grade table.
+  assert.match(updateQ().sql, /^\s*UPDATE ideas_grades/i);
+});
+
+await test('a DISTINCT developer is recorded, and both parties are named in the response', async () => {
+  const r = await call({ builderId: '42' });
+  assert.equal(r.payload.idea.developed_by, '42');
+  assert.equal(r.payload.developer_id, '42');
+  assert.equal(r.payload.author_id, '9');
+  assert.equal(r.payload.self_developed, false);
+  assert.equal(updateQ().params.at(-1), '42', 'the developer is the AUTHENTICATED builder, not a body field');
+});
+
+await test('self-development is legal and reported as such', async () => {
+  developRows[0].developed_by = '9';
+  const r = await call({ builderId: '9' });
+  assert.equal(r.status, 200, 'an author may develop their own spark');
+  assert.equal(r.payload.self_developed, true);
+});
+
+await test('the developer cannot be spoofed: the body allowlist REFUSES the field', async () => {
+  // The write takes req.builder.id (asserted above), and the validator is a
+  // strict allowlist on top of that — so an attempt to name a developer, or to
+  // rewrite the author, is refused by NAME before the handler reads anything.
+  for (const spoof of ['developed_by', 'developer_id', 'captured_by']) {
+    queries = [];
+    const r = await call({ body: { field_values: FULL, [spoof]: '1' } });
+    assert.equal(r.status, 400, `${spoof} is not an accepted body field`);
+    assert.equal(r.payload.error, 'validation_failed');
+    assert.deepEqual(r.payload.details, [{ field: spoof, reason: 'unknown_field' }], 'the refused field is named');
+    assert.equal(writes().length, 0);
+  }
+});
+
+// --- developed only once, and where that is actually enforced -----------
+
+await test('"only once" lives in the UPDATE predicate, not in a read-then-write', async () => {
+  await call();
+  const sql = updateQ().sql;
+  assert.match(sql, /WHERE idea_id = \$1/);
+  assert.match(sql, /AND grade = 'spark'/, 'the guard is in the write, so a race cannot double-develop');
+});
+
+await test('a lost race is a 409, and the winner\'s work is not overwritten', async () => {
+  developRows = []; // the guard matched zero rows: someone developed it first
+  const r = await call();
+  assert.equal(r.status, 409);
+  assert.equal(r.payload.error, 'spark_already_developed');
+  assert.match(r.payload.reason, /their version stands/);
+});
+
+await test('an ALREADY-DEVELOPED idea is refused before any write', async () => {
+  idea.grade = 'full';
+  idea.developed_by = '7';
+  const r = await call();
+  assert.equal(r.status, 409);
+  assert.equal(r.payload.error, 'not_a_spark');
+  assert.equal(r.payload.developed_by, '7', 'it says who got there first');
+  assert.equal(writes().length, 0);
+});
+
+await test('a QUICK idea cannot be developed — there is no consent to develop it', async () => {
+  idea.grade = 'quick';
+  const r = await call();
+  assert.equal(r.status, 409);
+  assert.equal(r.payload.error, 'not_a_spark');
+  assert.match(r.payload.reason, /author has to mark it first/);
+  assert.equal(writes().length, 0);
+});
+
+// --- a spark is not necessarily still DEVELOPABLE (grader finding, R146) -
+
+// Triage writes idea_inbox.status and NEVER touches ideas_grades, so a discarded
+// or promoted spark keeps grade='spark' forever. Grade alone therefore does not
+// mean "still developable" — and developing a dead idea would open a fresh board
+// ratification window for content triage already killed.
+for (const dead of ['discarded', 'promoted', 'merged']) {
+  await test(`a ${dead} spark cannot be developed, even though its grade is still 'spark'`, async () => {
+    idea.status = dead;
+    const r = await call();
+    assert.equal(r.status, 409);
+    assert.equal(r.payload.error, 'idea_not_open');
+    assert.equal(r.payload.status, dead);
+    assert.equal(writes().length, 0, 'refused before any write');
+    assert.ok(!portsResolved.includes('government'), 'and no board window is opened for a dead idea');
+  });
+}
+
+await test('the status guard is in the WRITE PREDICATE too, not just the pre-check', async () => {
+  await call();
+  const sql = updateQ().sql;
+  // A pre-check cannot stop a triager who discards the idea mid-request; the fix
+  // for a race is never a check that ran earlier.
+  assert.match(sql, /EXISTS/i);
+  assert.match(sql, /idea_inbox i WHERE i\.id = \$1 AND i\.status = 'open'/);
+});
+
+await test('losing to a TRIAGER mid-request is reported as such, not as a lost race', async () => {
+  developRows = [];              // the guard fired
+  idea.status = 'discarded';     // ...because triage closed it
+  // The pre-check catches this one first, which is the desired outcome; the
+  // post-write branch below covers the genuinely concurrent case.
+  const r = await call();
+  assert.equal(r.payload.error, 'idea_not_open');
+});
+
+await test('a spark closed BETWEEN the read and the write reports the triager, not a rival', async () => {
+  developRows = [];
+  // Open on the pre-read, closed by the time the re-read happens.
+  let reads = 0;
+  api.pool.query = async (sql, params = []) => {
+    queries.push({ sql, params });
+    if (/UPDATE ideas_grades/i.test(sql)) return { rows: [] };
+    if (/FROM idea_inbox/i.test(sql)) {
+      reads += 1;
+      return { rows: [{ ...idea, status: reads === 1 ? 'open' : 'discarded' }] };
+    }
+    return { rows: [] };
+  };
+  const r = await call();
+  assert.equal(r.status, 409);
+  assert.equal(r.payload.error, 'idea_not_open');
+  assert.equal(r.payload.status, 'discarded');
+  assert.match(r.payload.reason, /triager closed this idea while you were developing it/);
+});
+
+// --- the same standard as any other Full Idea --------------------------
+
+await test('an invalid field set is a 400 NAMING the field, and nothing is written', async () => {
+  const r = await call({ body: { field_values: { ...FULL, rogue: 'x' } } });
+  assert.equal(r.status, 400);
+  assert.equal(r.payload.error, 'invalid_field_values');
+  assert.deepEqual(r.payload.errors, [{ field: 'rogue', reason: 'unknown_field' }]);
+  assert.equal(writes().length, 0, 'a spark is not consumed by a failed attempt');
+});
+
+await test('a missing required field is refused the same way', async () => {
+  const { fit, ...four } = FULL;
+  const r = await call({ body: { field_values: four } });
+  assert.equal(r.status, 400);
+  assert.ok(r.payload.errors.some((e) => e.field === 'fit' && e.reason === 'missing_required'));
+  assert.equal(writes().length, 0);
+});
+
+await test('field_values is required — an empty develop is not a developed idea', async () => {
+  const r = await call({ body: {} });
+  assert.equal(r.status, 400);
+  assert.equal(writes().length, 0);
+});
+
+await test('a missing idea is a 404, not a 500', async () => {
+  idea = null;
+  const r = await call();
+  assert.equal(r.status, 404);
+  assert.equal(r.payload.error, 'idea_not_found');
+  assert.equal(writes().length, 0);
+});
+
+// --- the money boundary: R147 owns the split ---------------------------
+
+// R146 shipped this route paying NOTHING on purpose: with two people involved the
+// recipient was ambiguous, and awardIdeaFullPassCredit's idempotency predicate is
+// (builder_id, reason) — so guessing the developer would not have blocked a later
+// payment to the author, and one idea would have paid twice. R147 (ADR 0185)
+// resolved that by moving the payee decision INTO the economy module, so this
+// route can now call it safely: it no longer chooses who earns.
+await test('the stream-2 pass credit IS paid here now, and the route does not pick the payee', async () => {
+  let seen = null;
+  api.resolveOptional = (name) => {
+    portsResolved.push(name);
+    if (name === 'reward') {
+      return {
+        awardIdeaFullPassCredit: async (_client, args) => {
+          seen = args;
+          return { credited: 5, reason: 'paid', payees: [
+            { builderId: '42', delta: 4, role: 'developer', booked: true },
+            { builderId: '9', delta: 1, role: 'spark_author', booked: true },
+          ] };
+        },
+      };
+    }
+    return undefined;
+  };
+  const r = await call();
+  assert.equal(r.status, 200);
+  assert.ok(portsResolved.includes('reward'), 'the reward port is consulted');
+  assert.equal(r.payload.idea.ideator_credit, 5, 'the total is surfaced');
+  assert.equal(r.payload.idea.ideator_credit_split.length, 2, 'and the per-payee breakdown');
+  // The route hands over the idea and the score — never a chosen recipient beyond
+  // the author fallback the economy module overrides from the DB.
+  assert.equal(seen.ideaId, 77);
+  assert.equal(seen.completenessScore, 100);
+  assert.ok(!('developedBy' in seen), 'the route does not tell economy who developed it');
+});
+
+await test('a credit failure does not roll back the development (fail-open)', async () => {
+  api.resolveOptional = (name) => {
+    portsResolved.push(name);
+    if (name === 'reward') return { awardIdeaFullPassCredit: async () => { throw new Error('synthetic credit outage'); } };
+    return undefined;
+  };
+  const r = await call();
+  assert.equal(r.status, 200, 'the development landed');
+  assert.equal(r.payload.developed, true);
+  assert.equal(r.payload.idea.ideator_credit, undefined);
+});
+
+await test('but the board window IS opened — otherwise the handoff dead-ends', async () => {
+  await call();
+  // Recipient-agnostic (an idea and a score, no builder), and without it a
+  // developed Full Idea could never reach ratification.
+  assert.ok(portsResolved.includes('government'), 'the government port is consulted');
+});
+
+await test('a board-window failure does not roll back the development (fail-open)', async () => {
+  api.resolveOptional = (name) => {
+    portsResolved.push(name);
+    if (name === 'government') return { openBoardWindowForIdea: async () => { throw new Error('synthetic board outage'); } };
+    return undefined;
+  };
+  const r = await call();
+  assert.equal(r.status, 200, 'the development landed');
+  assert.equal(r.payload.developed, true);
+  assert.equal(r.payload.board_window, undefined);
+  api.resolveOptional = (name) => { portsResolved.push(name); return undefined; };
+});
+
+api.resolveOptional = realResolveOptional;
+
+// --- what the developer actually reads -----------------------------------
+
+const cli = require('../scripts/gds/spark.js');
+
+await test('the CLI names both parties, and never prints "undefined"', () => {
+  const out = cli.renderDeveloped({
+    idea: { id: '77', completeness_score: 88 },
+    author_id: '9', developer_id: '42', self_developed: false,
+    board_window: { item_id: '3', closes_at: '2026-08-29T00:00:00Z' },
+  });
+  assert.match(out, /completeness 88\/100/);
+  assert.match(out, /\/builders\/#\/idea\/77/, 'the hall link, never a bare ref');
+  assert.match(out, /credited to builder 9/, 'the author keeps the thought');
+  assert.match(out, /developer \(42\)/);
+  assert.match(out, /ratification window is open/);
+  assert.doesNotMatch(out, /undefined|null/);
+});
+
+await test('self-development reads as one person, not a handoff to yourself', () => {
+  const out = cli.renderDeveloped({ idea: { id: '1', completeness_score: 70 }, author_id: '9', developer_id: '9', self_developed: true });
+  assert.match(out, /You had the thought and you developed it/);
+  assert.doesNotMatch(out, /credited to builder/);
+});
+
+await test('a sub-bar result says WHICH section is thinnest', () => {
+  const out = cli.renderDeveloped({
+    idea: { id: '1', completeness_score: 40, rejection: { section_key: 'why_matters', reason_md: 'barely there' } },
+    author_id: '9', developer_id: '42', self_developed: false,
+  });
+  assert.match(out, /thinnest section: why_matters/);
+  assert.match(out, /barely there/);
+  assert.doesNotMatch(out, /ratification window/, 'no window was opened');
+});
+
+await test('an unscored idea says so rather than printing nothing', () => {
+  const out = cli.renderDeveloped({ idea: { id: '1', completeness_score: null }, author_id: '9', developer_id: '42' });
+  assert.match(out, /completeness unscored\/100/);
+});
+
+await test('--template is read from the R141 declaration, not restated', () => {
+  const out = cli.templateSkeleton();
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(out.includes(f.key), `names ${f.key}`);
+    assert.ok(out.includes(f.label), `names the label for ${f.key}`);
+  }
+  assert.match(out, /padding scores nothing/, 'it warns about the substance floor');
+  // The skeleton must be valid JSON for the five keys, or --fields-file advice lies.
+  const json = out.slice(out.indexOf('{'), out.lastIndexOf('}') + 1);
+  assert.deepEqual(Object.keys(JSON.parse(json)).sort(), BASE_TEMPLATE.fields.map((f) => f.key).sort());
+});
+
+await test('the CLI explains each server refusal in the developer\'s own terms', () => {
+  const { envelope } = require('../src/bongos/api-errors.js');
+  const already = cli.explain(409, envelope('not_a_spark', undefined, { grade: 'full', developed_by: '7' }));
+  assert.match(already, /already been developed/);
+  assert.match(already, /builder 7/);
+  assert.doesNotMatch(already, /undefined/);
+
+  const notMarked = cli.explain(409, envelope('not_a_spark', undefined, { grade: 'quick' }));
+  assert.match(notMarked, /author has to mark it first/);
+
+  const race = cli.explain(409, envelope('spark_already_developed', undefined, {}));
+  assert.match(race, /Their version stands/);
+
+  const bad = cli.explain(400, envelope('invalid_field_values', undefined, { errors: [{ field: 'fit', reason: 'missing_required' }] }));
+  assert.match(bad, /fit: missing required/);
+});
+
+console.log(`\nidea_develop_spark: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/idea_full_pass_credit.mjs

@@ -28,23 +28,35 @@ async function test(name, fn) {
   catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
 }
 
-// A stub client whose credit_log "table" is an in-memory set of reasons, so the
-// INSERT ... WHERE NOT EXISTS (SELECT 1 ... WHERE reason=$3) behaves exactly like
-// Postgres: the second insert of the same reason is a no-op (rowCount 0).
-function stubClient() {
+// A stub client whose credit_log "table" is an in-memory set of (builder, reason)
+// pairs, so the INSERT ... WHERE NOT EXISTS behaves exactly like Postgres: a
+// second insert for the same pair is a no-op (rowCount 0).
+//
+// R147 (task 1002923) reshaped the write: the function now first LOOKS UP the
+// idea's parties (captured_by + developed_by) so it — not its caller — decides
+// who earns, and the INSERT carries task_id as a parameter, moving `reason` from
+// $3 to $4. `developedBy` here defaults to null, i.e. an idea nobody developed,
+// which is the case every test below was written for; the split itself is
+// covered in tests/idea_credit_split.mjs.
+function stubClient({ authorId = null, developedBy = null } = {}) {
   const rows = [];
   return {
     rows,
     async query(sql, params) {
-      // our fn issues exactly one INSERT ... SELECT ... WHERE NOT EXISTS, whose
-      // subquery filters on builder_id AND reason (the index-friendly predicate).
-      // Mirror both terms so the stub matches the real query.
+      // The R147 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 subquery must still scope by builder_id AND reason. That
+      // was an index concern before (idx_credit_log_builder); under R147 it is
+      // also load-bearing for correctness, because a split books two rows under
+      // ONE reason and a reason-only predicate would refuse the second payee.
       const builderId = params[0];
-      const reason = params[2];
-      assert.match(sql, /builder_id = \$1 AND reason = \$3/, 'idempotency check must scope by builder_id to hit the index');
+      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, delta: params[1], reason, description: params[3] });
+      rows.push({ builder_id: builderId, delta: params[2], reason, description: params[4] });
       return { rowCount: 1, rows: [] };
     },
   };
@@ -54,7 +66,7 @@ const PASS = 72;   // clears the 60 bar
 const THIN = 40;   // below the bar
 
 await test('a passing Full Idea books exactly 5 credits to its author', async () => {
-  const c = stubClient();
+  const c = stubClient({ authorId: 3 });
   const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 9, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } });
   assert.equal(r.credited, credits.IDEA_FULL_PASS_CREDIT);
   assert.equal(r.reason, 'paid');
@@ -65,7 +77,7 @@ await test('a passing Full Idea books exactly 5 credits to its author', async ()
 });
 
 await test('re-running pays nothing — idempotent per idea', async () => {
-  const c = stubClient();
+  const c = stubClient({ authorId: 3 });
   const opts = { ideaId: 9, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } };
   const first = await credits.awardIdeaFullPassCredit(c, opts);
   const second = await credits.awardIdeaFullPassCredit(c, opts);
@@ -78,7 +90,7 @@ await test('re-running pays nothing — idempotent per idea', async () => {
 });
 
 await test('a below-bar or null score books 0 — scoring gates the pay, not capture', async () => {
-  const c = stubClient();
+  const c = stubClient({ authorId: 3 });
   assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 1, authorId: 3, completenessScore: THIN, config: { ideatorCredit: true } })).reason, 'below_bar');
   assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 2, authorId: 3, completenessScore: null, config: { ideatorCredit: true } })).reason, 'below_bar');
   assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 3, authorId: 3, completenessScore: undefined, config: { ideatorCredit: true } })).reason, 'below_bar');
@@ -90,13 +102,13 @@ await test('COST-PLUS-ONLY does NOT suppress it: the ideator lane pays regardles
   const policy = credits.rewardPolicy({ mode: 'cost-plus-only' });
   assert.equal(policy.perTaskCredit, false);
   assert.equal(policy.ideatorCredit, true);
-  const c = stubClient();
+  const c = stubClient({ authorId: 3 });
   const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 5, authorId: 3, completenessScore: PASS, config: policy });
   assert.equal(r.credited, 5, '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();
+  const c = stubClient({ authorId: 3 });
   const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 6, authorId: 3, completenessScore: PASS, config: { ideatorCredit: false } });
   assert.equal(r.credited, 0);
   assert.equal(r.reason, 'ideator_lane_off');
@@ -104,9 +116,29 @@ await test('an instance that opts the ideator lane out pays nothing', async () =
 });
 
 await test('a missing author or idea is a safe 0, never a throw', async () => {
-  const c = stubClient();
-  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 6, authorId: null, completenessScore: PASS, config: { ideatorCredit: true } })).reason, 'missing_author_or_idea');
-  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: null, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } })).reason, 'missing_author_or_idea');
+  // No ideaId at all: refused before the parties lookup even runs.
+  const noIdea = stubClient({ authorId: 3 });
+  assert.equal((await credits.awardIdeaFullPassCredit(noIdea, { ideaId: null, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } })).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.awardIdeaFullPassCredit(unknown, { ideaId: 6, authorId: null, completenessScore: PASS, config: { ideatorCredit: true } })).reason, 'missing_author_or_idea');
+  assert.equal(unknown.rows.length, 0);
+});
+
+await test('R147: the DB is authoritative for the author; the argument is only a fallback', async () => {
+  // The caller passing null no longer matters when the row is readable — the
+  // whole point of moving the payee decision into this module.
+  const known = stubClient({ authorId: 3 });
+  const r = await credits.awardIdeaFullPassCredit(known, { ideaId: 6, authorId: null, completenessScore: PASS, config: { ideatorCredit: true } });
+  assert.equal(r.credited, credits.IDEA_FULL_PASS_CREDIT);
+  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.awardIdeaFullPassCredit(invisible, { ideaId: 6, authorId: 7, completenessScore: PASS, config: { ideatorCredit: true } });
+  assert.equal(f.credited, credits.IDEA_FULL_PASS_CREDIT);
+  assert.equal(invisible.rows[0].builder_id, 7);
 });
 
 console.log(`\nidea_full_pass_credit: ${passed} passed, ${failed} failed`);

package/tests/idea_spark_queue.mjs

@@ -101,13 +101,21 @@ await test('the queue asks for grade=spark AND status=open — nothing else', as
   assert.match(sql, /i\.status = 'open'/, 'only open ideas');
 });
 
-await test('a DEVELOPED spark leaves the queue by GRADE, with no `developed` flag', async () => {
+await test('a DEVELOPED spark leaves the queue by GRADE, not by a `developed` filter', async () => {
   await call();
   const sql = listSql().sql;
   // R146 develops in place and flips the grade spark→full, so grade='spark' IS
   // "not yet developed". A second source of truth could disagree with the grade.
-  assert.doesNotMatch(sql, /developed/i, 'no separate developed column/flag');
-  assert.doesNotMatch(sql, /promoted_to_task_id\s*IS\s*NULL/i, 'exit is the grade flip, not a promote link');
+  //
+  // The invariant is about the PREDICATE, so only the predicate is asserted.
+  // R146 later added developed_by/developed_at to the SELECT list (attribution
+  // rides along on every idea read) — that is not a filter and must not trip this.
+  const predicate = sql.slice(sql.search(/\bWHERE\b/i));
+  assert.doesNotMatch(predicate, /developed/i, 'nothing in the WHERE keys off a developed flag');
+  assert.doesNotMatch(predicate, /promoted_to_task_id\s*IS\s*NULL/i, 'exit is the grade flip, not a promote link');
+  // And the positive half, so the two tasks' expectations are explicit rather
+  // than merely non-conflicting: the attribution IS returned.
+  assert.match(sql, /g\.developed_by/, 'who developed it rides along on the read (R146)');
 });
 
 await test('newest first, with a stable tiebreak', async () => {