@bongos/core 1.19.296 → 1.19.297

package/tests/idea_develop_spark.mjs

@@ -0,0 +1,399 @@
+// 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: one case below swaps in a two-phase stub to simulate a
+  // triager closing the idea mid-request, and it must not leak into the next.
+  api.pool.query = basePoolQuery;
+  // 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 ---------------------------
+
+await test('the stream-2 pass credit is NOT paid here — R147 owns the split', async () => {
+  const r = await call();
+  assert.equal(r.status, 200);
+  // Stronger than "no INSERT INTO credit_log": the handler never even asks for
+  // the reward port. awardIdeaFullPassCredit is idempotent per (builder, idea),
+  // so paying the DEVELOPER here would NOT block a later payment to the AUTHOR —
+  // the same idea would pay twice.
+  assert.ok(!portsResolved.includes('reward'), 'the reward port is never resolved on the develop path');
+  assert.ok(!queries.some((q) => /credit_log/i.test(q.sql)), 'no credit is booked');
+  assert.equal(r.payload.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_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 () => {