@bongos/core 1.19.297 → 1.19.299

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_hall_composer.mjs

@@ -0,0 +1,246 @@
+// tests/idea_hall_composer.mjs
+//
+// task 1002928 (BV1.R152, goal 1000062) — the hall's Full Idea composer.
+//
+// The done-when this file exists to make mechanical: "the meter reflects the REAL
+// scorer, not a second copy of the rules". The cheap way to violate that is not a
+// re-implemented formula — it is five hand-written <textarea> elements in the
+// page, which fork the R141 template one step before any scoring happens. So the
+// central assertion here is a NEGATIVE one over the page source: no field key and
+// no field label may appear in it, at all. If someone hard-codes the form, this
+// fails, and the failure names the field they hard-coded.
+//
+// Also covered: the two routes the composer is built from (template projection,
+// score delegation), and the declaration-order trap that would 400 the template
+// read (`GET /inbox/:id` capturing the literal "template" — the third time this
+// shape has come up in this goal, after /inbox/sparks and /inbox/awaiting-nod).
+//
+// Route halves are DB-free the idea_full_capture.mjs way; the page halves are a
+// pure file read.
+//
+// Run:  node tests/idea_hall_composer.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+
+const api = require('../src/module-api.js');
+api.pool.query = async () => ({ rows: [] });
+
+const { BASE_TEMPLATE, fieldOrder } = require('../modules/ideas/templates.js');
+const { scoreFieldValues } = require('../modules/ideas/completeness.js');
+const routesFactory = require('../modules/ideas/routes/inbox.js');
+const router = routesFactory({});
+
+const mounted = router.stack.filter((l) => l.route)
+  .map((l) => `${Object.keys(l.route.methods)[0].toUpperCase()} ${l.route.path}`);
+
+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];
+}
+
+function call(handler, { query = {}, body = {} } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = { params: {}, query, body, builder: { id: '9', rank: 'xenos' } };
+    const res = {
+      statusCode: 200,
+      status(c) { this.statusCode = c; return this; },
+      json(payload) { resolve({ status: this.statusCode, payload }); },
+      fail(code, status, extra) {
+        const s = typeof status === 'number' ? status : (status && status.status) || 500;
+        resolve({ status: s, payload: { error: code, details: extra } });
+      },
+    };
+    Promise.resolve(handler(req, res, (e) => reject(e || new Error('next()')))).catch(reject);
+  });
+}
+
+const getTemplate = handlerFor('/inbox/template', 'get');
+const postScore = handlerFor('/inbox/score', 'post');
+
+const IDEAS_JS = fs.readFileSync(path.join(HALL, 'ideas.js'), 'utf8');
+const IDEAS_HTML = fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8');
+
+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 done-when: the page carries no copy of the rules ----------------
+
+await test('the PAGE names no field key — a hard-coded form is a forked template', () => {
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(!IDEAS_JS.includes(f.key), `ideas.js hard-codes the field key "${f.key}"`);
+    assert.ok(!IDEAS_HTML.includes(f.key), `ideas.html hard-codes the field key "${f.key}"`);
+  }
+});
+
+await test('the PAGE names no field label either', () => {
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(!IDEAS_JS.includes(f.label), `ideas.js hard-codes the label "${f.label}"`);
+    assert.ok(!IDEAS_HTML.includes(f.label), `ideas.html hard-codes the label "${f.label}"`);
+  }
+});
+
+await test('the page does NOT restate the substance floor', () => {
+  // A floor has to be attached to a field to mean anything, and the two
+  // assertions above already forbid naming one — this pins the scorer's own
+  // vocabulary out of the page as well, so "substanceMin: 40" cannot creep in
+  // under a different field name.
+  // camelCase `substanceMin` is the SCORER's own internal property name — a
+  // re-implementation would carry it. The published snake_case `substance_min` is
+  // deliberately NOT forbidden: it is a field of the template response the page
+  // legitimately receives, and naming it in a comment that documents that shape
+  // is documentation, not a forked rule.
+  assert.ok(!IDEAS_JS.includes('substanceMin'), 'ideas.js restates the scorer\'s floor');
+});
+
+await test('the page gets both the FORM and the METER from the server', () => {
+  // The positive half: it is not rule-free because it renders nothing — it is
+  // rule-free because it asks. Both calls must actually be there.
+  assert.match(IDEAS_JS, /getInboxTemplate/, 'the form is rendered from GET /inbox/template');
+  assert.match(IDEAS_JS, /postInboxScore/, 'the meter is filled from POST /inbox/score');
+  assert.match(IDEAS_JS, /postInbox\b/, 'and it files through POST /inbox');
+});
+
+await test('the page does not print a pass bar — that rule lives in economy', () => {
+  // The ideas scorer is documented bar-AGNOSTIC; the pass bar sits with the credit
+  // it gates. A threshold printed here would be a second copy of a DIFFERENT rule.
+  const { IDEA_FULL_PASS_BAR } = require('../modules/economy/credits.js');
+  assert.ok(Number.isInteger(IDEA_FULL_PASS_BAR), 'the bar is a number in economy');
+  assert.ok(!new RegExp(`\\b${IDEA_FULL_PASS_BAR}\\b`).test(IDEAS_JS), 'ideas.js names the economy pass bar');
+});
+
+// --- drafts survive navigation ------------------------------------------
+
+await test('every localStorage touch is guarded — storage that throws must not down the page', () => {
+  // A private window, cleared site data, or a browser set to block storage all
+  // THROW on access. Count the accesses and the guards rather than trusting a
+  // reading of the code.
+  const accesses = (IDEAS_JS.match(/localStorage\./g) || []).length;
+  assert.ok(accesses >= 3, 'the draft feature reads, writes and clears');
+  const tries = (IDEAS_JS.match(/try\s*\{/g) || []).length;
+  assert.ok(tries >= 3, `each localStorage access sits in its own try (found ${tries} for ${accesses} accesses)`);
+});
+
+await test('the draft is cleared only AFTER a successful file, never before', () => {
+  // A failed POST must not cost the text. Assert the ordering in the source: the
+  // clearDraft() call inside file() comes after the !r.ok early return.
+  const body = IDEAS_JS.slice(IDEAS_JS.indexOf('async function file('));
+  const bail = body.indexOf('if (!r.ok)');
+  const clear = body.indexOf('clearDraft()');
+  assert.ok(bail > 0 && clear > 0, 'both the failure bail and the clear are present');
+  assert.ok(clear > bail, 'clearDraft() must come after the failure path returns');
+});
+
+await test('a draft written against another template is dropped, not half-restored', () => {
+  assert.match(IDEAS_JS, /template_key/, 'the draft records which template it was written for');
+});
+
+// --- GET /inbox/template ------------------------------------------------
+
+await test('GET /inbox/template is declared BEFORE GET /inbox/:id', () => {
+  const iT = mounted.indexOf('GET /inbox/template');
+  const iId = mounted.indexOf('GET /inbox/:id');
+  assert.ok(iT >= 0 && iId >= 0);
+  assert.ok(iT < iId, `with :id first, "/inbox/template" binds id="template" and parseId 400s it (template@${iT}, :id@${iId})`);
+});
+
+await test('the template read returns the R141 declaration, in fieldOrder order', async () => {
+  const r = await call(getTemplate);
+  assert.equal(r.status, 200);
+  const t = r.payload.template;
+  assert.equal(t.key, BASE_TEMPLATE.key);
+  assert.equal(t.label, BASE_TEMPLATE.label);
+  // fieldOrder returns KEYS, not field objects. Comparing two lists derived the
+  // same WRONG way proves nothing — the first run of this test passed while the
+  // endpoint was emitting five {key: undefined} descriptors, because both sides
+  // were [undefined × 5]. So assert against the declaration AND that the keys are
+  // real strings.
+  assert.deepEqual(t.fields.map((f) => f.key), fieldOrder(BASE_TEMPLATE),
+    'display order comes from fieldOrder, never jsonb key order');
+  assert.ok(t.fields.length >= 1);
+  for (const f of t.fields) {
+    assert.equal(typeof f.key, 'string', 'a field descriptor carries a real key');
+    assert.ok(f.key.length > 0);
+    assert.equal(typeof f.label, 'string');
+    assert.ok(f.label.length > 0, 'and a real label — five unlabeled boxes is the bug this catches');
+  }
+  for (const f of t.fields) {
+    const src = BASE_TEMPLATE.fields.find((x) => x.key === f.key);
+    assert.equal(f.label, src.label);
+    assert.equal(f.required, !!src.required);
+    assert.equal(f.substance_min, src.substanceMin || 0, 'the floor is published so the form can say how much more is wanted');
+  }
+});
+
+await test('an unknown template is a 404, not an empty form', async () => {
+  const r = await call(getTemplate, { query: { template_key: 'no-such-template' } });
+  assert.equal(r.status, 404);
+  assert.equal(r.payload.error, 'unknown_template');
+});
+
+// --- POST /inbox/score --------------------------------------------------
+
+await test('the score endpoint IS the scorer — identical output, not a reimplementation', async () => {
+  const cases = [
+    Object.fromEntries(BASE_TEMPLATE.fields.map((f) => [f.key, 'x'.repeat(80)])),      // full
+    Object.fromEntries(BASE_TEMPLATE.fields.map((f) => [f.key, 'tiny'])),              // thin
+    { [BASE_TEMPLATE.fields[0].key]: 'y'.repeat(200) },                                // one field only
+    {},                                                                                // empty
+  ];
+  for (const field_values of cases) {
+    const r = await call(postScore, { body: { field_values } });
+    assert.equal(r.status, 200);
+    const direct = scoreFieldValues(field_values);
+    assert.equal(r.payload.score, direct.score, 'same score as calling the scorer directly');
+    assert.deepEqual(r.payload.fields, direct.fields, 'same per-field breakdown, same order');
+  }
+});
+
+await test('whitespace scores as the nothing it is, through the endpoint too', async () => {
+  const padded = Object.fromEntries(BASE_TEMPLATE.fields.map((f) => [f.key, '   \n\n\t  ']));
+  const r = await call(postScore, { body: { field_values: padded } });
+  assert.equal(r.payload.score, 0);
+});
+
+await test('a half-written draft scores rather than 400ing', async () => {
+  // The composer scores on every keystroke, so most calls carry an incomplete set.
+  const r = await call(postScore, { body: { field_values: { [BASE_TEMPLATE.fields[0].key]: 'half a thought' } } });
+  assert.equal(r.status, 200);
+  assert.ok(Number.isInteger(r.payload.score));
+});
+
+await test('unscorable input is a null score, never an exception or a 400', async () => {
+  const r = await call(postScore, { body: { field_values: {}, template_key: 'no-such-template' } });
+  assert.equal(r.status, 200, 'R142 never throws into the caller; "cannot score" is a legal answer');
+  assert.equal(r.payload.score, null);
+  assert.deepEqual(r.payload.fields, []);
+});
+
+await test('field_values is required — scoring nothing is a client bug, not a 0', async () => {
+  const r = await call(postScore, { body: {} });
+  assert.equal(r.status, 400);
+});
+
+await test('neither read touches the database', async () => {
+  let touched = 0;
+  api.pool.query = async () => { touched += 1; return { rows: [] }; };
+  await call(getTemplate);
+  await call(postScore, { body: { field_values: { [BASE_TEMPLATE.fields[0].key]: 'a' } } });
+  assert.equal(touched, 0, 'both are pure — which is what makes a call per keystroke reasonable');
+});
+
+console.log(`\nidea_hall_composer: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);