@bongos/core 1.20.58 → 1.20.60

package/tests/role_stats_db.mjs

@@ -0,0 +1,237 @@
+// tests/role_stats_db.mjs — the two new money reads of WA6.RP03 (task 1004433)
+// against a REAL Postgres: economy's credits-by-craft split and the lifecycle's
+// per-person earnings fragment.
+//
+// WHY A REAL DATABASE. Both are WHERE-clause and JOIN questions — which ledger
+// rows a LIKE pattern reaches (the escaped underscore in the artist prefix), how
+// an empty session_records.task_ids array fans out through a LATERAL unnest,
+// and what numeric ROUND does to a half credit. A stubbed client answers
+// exactly the assumption under test (the session_earnings_mirror_db argument),
+// so tests/profile_role_stats.mjs covers the pure halves and this covers the SQL.
+//
+// It SELF-SKIPS (exit 0) without a reachable Postgres and is listed in
+// run-unit-tests.js's INTEGRATION set. Every test runs inside one transaction
+// under a savepoint and the whole run is rolled back: it writes nothing that
+// survives, so it is safe against a dev database.
+//
+// Run:  DATABASE_URL=postgres://... node tests/role_stats_db.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const byCraft = require('../modules/economy/credits-by-craft.js');
+const { creditsEarnedBySql, CREDITS_AWARDED_SUBQUERY } = require('../modules/lifecycle/db-tasks.js');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+let passed = 0;
+let failed = 0;
+let client;
+async function test(name, fn) {
+  await client.query('SAVEPOINT t');
+  try {
+    await fn();
+    passed++; console.log(`  ok  ${name}`);
+    await client.query('RELEASE SAVEPOINT t');
+  } catch (err) {
+    failed++; console.error(`  FAIL ${name}\n    ${err.message}`);
+    await client.query('ROLLBACK TO SAVEPOINT t');
+  }
+}
+
+// The schema-driven row builder session_earnings_mirror_db uses: fill every
+// NOT NULL column with no default, so the fixture survives a later migration
+// adding one.
+const schemaCache = new Map();
+async function columnsOf(table) {
+  if (schemaCache.has(table)) return schemaCache.get(table);
+  const { rows } = await client.query(
+    `SELECT column_name, data_type, is_nullable, column_default, is_identity
+       FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = $1`,
+    [table]
+  );
+  schemaCache.set(table, rows);
+  return rows;
+}
+function placeholderFor(dataType, columnName) {
+  switch (dataType) {
+    case 'integer': case 'bigint': case 'smallint':
+    case 'numeric': case 'real': case 'double precision':
+      return 0;
+    case 'boolean': return false;
+    case 'timestamp with time zone': case 'timestamp without time zone': case 'date':
+      return new Date();
+    case 'json': case 'jsonb': return {};
+    case 'ARRAY': return [];
+    default: return `rp03-${columnName}`;
+  }
+}
+async function insertRow(table, explicit = {}) {
+  const cols = await columnsOf(table);
+  if (cols.length === 0) throw new Error(`table ${table} not found — is this database migrated?`);
+  const values = { ...explicit };
+  for (const c of cols) {
+    if (c.column_name in values) continue;
+    if (c.is_nullable === 'YES' || c.column_default !== null || c.is_identity === 'YES') continue;
+    values[c.column_name] = placeholderFor(c.data_type, c.column_name);
+  }
+  const names = Object.keys(values);
+  const { rows } = await client.query(
+    `INSERT INTO ${table} (${names.map((n) => `"${n}"`).join(', ')})
+     VALUES (${names.map((_, i) => `$${i + 1}`).join(', ')}) RETURNING *`,
+    names.map((n) => values[n])
+  );
+  return rows[0];
+}
+function credit(builderId, { taskId = null, delta, reason, sessionId = null, basis = null }) {
+  return client.query(
+    `INSERT INTO credit_log (builder_id, task_id, delta, reason, description, session_id, reward_basis)
+     VALUES ($1, $2, $3, $4, 'rp03 test', $5, COALESCE($6::int, 0))`,
+    [builderId, taskId, delta, reason, sessionId, basis]
+  );
+}
+
+// One builder with a row in every branch of the classification, and a second
+// builder holding a row on the same task, who must never leak into the first.
+async function fixture() {
+  const tag = `rp03-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const b = await insertRow('builders', { github_id: `${tag}-gh`, github_login: tag, display_name: tag, total_credits: 0 });
+  const other = await insertRow('builders', { github_id: `${tag}-gh2`, github_login: `${tag}-2`, display_name: `${tag}-2`, total_credits: 0 });
+  const version = await insertRow('versions', { id: `${tag}-v`, status: 'building' });
+  const mk = (title, discipline) => insertRow('tasks', { title: `${tag} ${title}`, status: 'shipped', version_id: version.id, discipline });
+  const eng = await mk('eng', 'engineer');
+  const page = await mk('page', 'artist');
+  const ui = await mk('ui', 'ui');
+  const sid = `${tag}-session`;
+  await insertRow('session_records', { session_id: sid, builder_id: b.id, task_ids: [eng.id, ui.id], drachmae_earned: 0, total_tokens: 1 });
+  const lone = `${tag}-lone`;
+  await insertRow('session_records', { session_id: lone, builder_id: b.id, task_ids: [], drachmae_earned: 0, total_tokens: 1 });
+
+  await credit(b.id, { taskId: eng.id, delta: 10, reason: 'task.shipped' });
+  await credit(b.id, { taskId: page.id, delta: 30, reason: `tweak.page_approved:${page.id}` });
+  await credit(b.id, { taskId: eng.id, delta: 4, reason: `idea.credit.task_ship:5:${eng.id}` });
+  await credit(b.id, { delta: 5, reason: 'idea.credit.full_pass:5' });
+  await credit(b.id, { taskId: eng.id, delta: 2, reason: 'achievement.first_ship' });
+  await credit(b.id, { delta: 9, reason: 'session.token_reward', sessionId: sid, basis: 9 });
+  await credit(b.id, { delta: 3, reason: 'session.token_reward', sessionId: lone, basis: 3 });
+  // A LIKE-wildcard twin: an unescaped underscore would let this row read as an
+  // approved page. It is not one, so it must fall to `other`.
+  await credit(b.id, { delta: 7, reason: 'tweak.pageXapproved:1' });
+  await credit(other.id, { taskId: eng.id, delta: 50, reason: 'task.shipped' });
+  return { b, other, eng, page, ui };
+}
+
+async function main() {
+  try {
+    client = await pool.connect();
+  } catch {
+    console.log('role_stats_db: no Postgres (DATABASE_URL unset/unreachable) — skipping');
+    await pool.end().catch(() => {});
+    return;
+  }
+  await client.query('BEGIN');
+  try {
+    const f = await fixture();
+
+    await test('credits by craft: every reason lands in its craft and the parts sum to the ledger exactly', async () => {
+      const map = await byCraft.creditsByCraft([f.b.id], { client });
+      const row = map.get(String(f.b.id));
+      // engineer: 10 shipped + half of the 9 session + the 3 lone session = 17.5
+      // artist:   30 page + the ui half of the session (4.5)               = 34.5
+      // ideator:  4 stream 1 + 5 full pass                                 = 9
+      // other:    2 achievement + 7 wildcard twin                          = 9
+      assert.equal(row.ideator, 9);
+      assert.equal(row.other, 9);
+      assert.equal(row.total, 70);
+      assert.equal(row.engineer + row.artist + row.ideator + row.other, row.total, 'the parts are exact to the whole');
+      // 17.5 and 34.5 floor to 51 of 52; the one left over goes to the larger
+      // remainder, and on a tie to the earlier craft, engineer.
+      assert.equal(row.engineer, 18);
+      assert.equal(row.artist, 34);
+    });
+
+    await test('credits by craft: another builder on the same task is never counted', async () => {
+      const map = await byCraft.creditsByCraft([f.other.id], { client });
+      assert.equal(map.get(String(f.other.id)).engineer, 50);
+      assert.equal(map.get(String(f.other.id)).total, 50);
+    });
+
+    await test('person earnings: the per-task rows plus an even share of the session, this builder only', async () => {
+      const { rows } = await client.query(
+        `SELECT t.id, ${creditsEarnedBySql('$1')} AS c FROM tasks t WHERE t.id = ANY($2::bigint[]) ORDER BY t.id`,
+        [f.b.id, [f.eng.id, f.page.id, f.ui.id]]
+      );
+      const c = Object.fromEntries(rows.map((r) => [String(r.id), Number(r.c)]));
+      // eng: 10 shipped + 4 idea + round(9/2 = 4.5) = 19 (the achievement is not pay for the task)
+      assert.equal(c[String(f.eng.id)], 19);
+      assert.equal(c[String(f.page.id)], 30, 'the approved page is the artist pay for it');
+      assert.equal(c[String(f.ui.id)], 5, 'the other half of the session');
+      const { rows: o } = await client.query(`SELECT ${creditsEarnedBySql('$1')} AS c FROM tasks t WHERE t.id = $2`, [f.other.id, f.eng.id]);
+      assert.equal(Number(o[0].c), 50, 'the second builder reads their own pay, not the first one');
+    });
+
+    await test('main role: set, kept while still chosen, cleared when its craft is dropped, cleared on purpose', async () => {
+      const { UPDATE_BUILDER_DISCIPLINES_SQL: sql } = require('../src/bongos/db.js');
+      const run = async (list, setMain, main) =>
+        (await client.query(sql, [f.b.id, list, setMain, main])).rows[0].main_discipline;
+      assert.equal(await run(['engineer', 'artist'], true, 'artist'), 'artist', 'chosen');
+      assert.equal(await run(['engineer', 'artist', 'ideator'], false, null), 'artist', 'not mentioned, still one of the crafts: kept');
+      assert.equal(await run(['engineer'], false, null), null, 'the craft was dropped: a main role they no longer practise is cleared');
+      assert.equal(await run(['engineer'], true, 'engineer'), 'engineer');
+      assert.equal(await run(['engineer'], true, null), null, 'cleared on purpose');
+    });
+
+    await test('artist page read: only rounds whose LATEST web claim is theirs, never a CLI claim, never an ordinary task', async () => {
+      const { listPageTweakTasks } = require('../modules/lifecycle/page-tweak-reads.js');
+      const tag = `rp03p-${Date.now()}`;
+      const version = await insertRow('versions', { id: `${tag}-v`, status: 'building' });
+      const mk = (title, extra) => insertRow('tasks', { title: `${tag} ${title}`, status: 'shipped', version_id: version.id, discipline: 'artist', ...extra });
+      const mine = await mk('mine', { source: 'page-tweak', source_ref: `page-tweak/landing:${tag}a/r1` });
+      const takenOver = await mk('taken over', { source: 'page-tweak', source_ref: `page-tweak/landing:${tag}b/r1` });
+      const cliOnly = await mk('cli only', { source: 'page-tweak', source_ref: `page-tweak/landing:${tag}c/r1` });
+      const ordinary = await mk('ordinary', {});
+      const t0 = Date.now() - 60 * 60 * 1000;
+      const claim = (taskId, builderId, minutes, worktree = null) => insertRow('claims', {
+        task_id: taskId, builder_id: builderId, worktree_name: worktree, creator_session_id: null,
+        claimed_at: new Date(t0 + minutes * 60 * 1000), released_at: new Date(t0 + (minutes + 1) * 60 * 1000),
+      });
+      await claim(mine.id, f.b.id, 0);
+      await claim(takenOver.id, f.b.id, 0);
+      await claim(takenOver.id, f.other.id, 5);          // the later web claim is someone else's
+      await claim(cliOnly.id, f.b.id, 0, `${tag}-wt`);   // a worktree claim is an applier, not an artist
+      await claim(ordinary.id, f.b.id, 0);
+
+      const scoped = await listPageTweakTasks({ artistId: f.b.id, client });
+      assert.deepEqual(scoped.map((r) => String(r.id)), [String(mine.id)]);
+      assert.equal(String(scoped[0].artist_id), String(f.b.id));
+
+      const theirs = await listPageTweakTasks({ artistId: f.other.id, client });
+      assert.deepEqual(theirs.map((r) => String(r.id)), [String(takenOver.id)]);
+
+      const all = (await listPageTweakTasks({ client })).map((r) => String(r.id));
+      for (const id of [mine.id, takenOver.id, cliOnly.id]) assert.ok(all.includes(String(id)), 'the unscoped read is unchanged: every page round');
+      assert.ok(!all.includes(String(ordinary.id)));
+    });
+
+    await test('task payout: the approved page and the idea row now count, the achievement still does not', async () => {
+      const { rows } = await client.query(
+        `SELECT t.id, ${CREDITS_AWARDED_SUBQUERY} AS c FROM tasks t WHERE t.id = ANY($1::bigint[])`,
+        [[f.eng.id, f.page.id]]
+      );
+      const c = Object.fromEntries(rows.map((r) => [String(r.id), Number(r.c)]));
+      assert.equal(c[String(f.page.id)], 30);
+      assert.equal(c[String(f.eng.id)], 10 + 4 + 50, 'both shippers and the idea, no achievement, no session');
+    });
+  } finally {
+    await client.query('ROLLBACK').catch(() => {});
+    client.release();
+    await pool.end().catch(() => {});
+  }
+  console.log(`\n${passed} passed, ${failed} failed`);
+  if (failed) process.exit(1);
+}
+
+main().catch((err) => { console.error(err); process.exit(1); });

package/tests/tweak_replaces_artist_review.mjs

@@ -51,7 +51,7 @@ api.pool = {
   async query(sql, params = []) {
     const q = flat(sql);
     seen.push({ q, params });
-    if (/FROM tasks t LEFT JOIN task_grades g/.test(q)) return { rows: F.TASKS };
+    if (/FROM pt JOIN tasks t ON t\.id = pt\.id LEFT JOIN task_grades g/.test(q)) return { rows: F.TASKS };
     if (/t\.touches && \$1::text\[\]/.test(q)) {
       // The real query's predicate, applied to the one ship: shipped after the
       // page's last round, touching one of the page's files.

package/tests/wizard_draft_resume.mjs

@@ -90,9 +90,9 @@ test('post-auth: the real step is rendered', () => {
 
 test('a draft already at step 1 is unchanged, and an out-of-range step is not resurrected', () => {
   assert.equal(runStep({ authKnown: false, draftStep: 1 }).persisted.step, 1);
-  // 11 is the done panel (9 before task 1004417's front door, 8 before task 1004351), reached by its own branch
+  // 12 is the done panel (11 before task 1004421's Look step, 9 before task 1004417's front door, 8 before task 1004351), reached by its own branch
   // above this slice; 0 is the gate. Neither is a resumable wizard position, so the placeholder is allowed to stand.
-  for (const bad of [0, 11, 99]) {
+  for (const bad of [0, 12, 99]) {
     assert.equal(runStep({ authKnown: false, draftStep: bad }).persisted.step, 1, `step ${bad} is not resumed`);
   }
 });

package/tests/wizard_front_door.mjs

@@ -53,7 +53,7 @@ test('the front door stands between sign-in and the name step: gate 0, terms 1,
 
 test('the rail is the numbered steps\' — it steps aside on both front-door screens, statically too', () => {
   const beats = [...HUB.matchAll(/<li[^>]*data-step="(\d+)"/g)].map((m) => Number(m[1]));
-  assert.deepEqual(beats, [3, 4, 5, 6, 7, 8, 9, 10], 'the rail numbers name…create, never the front door');
+  assert.deepEqual(beats, [3, 4, 5, 6, 7, 8, 9, 10, 11], 'the rail numbers name…create, never the front door');
   assert.match(HUB, /<div class="card wizFront">/, 'a no-script visitor on the static first screen sees no rail');
   assert.match(STYLE, /#view-new \.card\.wizFront \.steps\{display:none;\}/);
 });
@@ -250,7 +250,7 @@ test('the create carries the tick, and is never filed without it', () => {
 test('the tick is part of the draft and of the reset, and the draft key moved with the renumbering', () => {
   assert.match(SCRIPT, /var state = \{ step: 0,[^}]*termsAck: false \};/, 'the initial state declares it');
   assert.match(SCRIPT, /state = \{ step: 1,[^}]*termsAck: false \};/, 'and "start another project" clears it — each project records its own');
-  assert.match(SCRIPT, /var DRAFT_KEY = 'cb-create-draft-v6';/, 'a draft saved under the old numbering is ignored, not replayed onto the wrong screen');
+  assert.match(SCRIPT, /var DRAFT_KEY = 'cb-create-draft-v7';/, 'a draft saved under the old numbering is ignored, not replayed onto the wrong screen');
 });
 
 // ── the look-before-you-ship kit walks it ─────────────────────────────────────

package/tests/wizard_intent_resume.mjs

@@ -15,12 +15,12 @@
 // ruled out the task's other option (drop the record at a terminal state).
 //
 // The reset fires only when there is a SECOND DRAFT to lose, and the draft's own step is
-// what says so. A landed create clears DRAFT_KEY — but show(11) then persists the done
+// what says so. A landed create clears DRAFT_KEY — but show(12) then persists the done
 // panel's position straight back into it, so a plain "is there a draft?" test is always
 // yes and would skip the reset forever, leaving the finished project's name sitting in
 // the fresh form. (That is exactly what the first cut of this change shipped into a
 // render: "still watching Mercury" above a name field still reading "Mercury".) Only
-// steps 1-10 are wizard steps (1-8 before task 1004417's front door took 1 and 2);
+// steps 1-11 are wizard steps (1-10 before task 1004421's Look step, 1-8 before task 1004417's front door took 1 and 2);
 // anything else is the done panel's own bookkeeping.
 //
 // Harness: there is no jsdom in this repo, so this follows tests/wizard_draft_resume.mjs
@@ -58,8 +58,8 @@ test('both slices are still findable (a rename must fail loudly, not silently pa
   assert.ok(offerSlice, 'paintResumeOffer() was not found in projects.html');
   assert.match(enterSlice, /if \(focus && !resumeIntent\) \{/, 'the intent branch is part of the slice');
   assert.match(enterSlice, /startProgress\(created\.id\);/, 'so is the resume branch it guards');
-  assert.match(enterSlice, /draft\.step >= 1 && draft\.step <= 10/,
-    'the STORED draft\'s step decides, not state.step — state.step is 11 for the whole life of a finished standup');
+  assert.match(enterSlice, /draft\.step >= 1 && draft\.step <= 11/,
+    'the STORED draft\'s step decides, not state.step — state.step is 12 for the whole life of a finished standup');
   assert.match(SCRIPT, /if \(created && created\.id\) \{ enterCreated\(created, !!focus\); return; \}/,
     'enter() still hands the created record straight to it');
 });
@@ -73,7 +73,7 @@ function runEnter({ focus, resumeIntent = false, draft = null, record }) {
   const calls = { show: [], resets: 0, offer: [], done: 0, progress: [], polls: 0, focused: 0 };
   // state.step is the DONE step for the whole life of a finished standup — the value
   // a draft-blind reading would have trusted
-  const state = { step: draft ? draft.step : 11, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
+  const state = { step: draft ? draft.step : 12, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
   const sandbox = {
     record, focus, resumeIntent, state,
     DRAFT_KEY: 'draft',
@@ -99,7 +99,7 @@ const REC = { id: 'inst-1', name: 'Acme', slug: 'acme', domain: 'acme.example',
 
 test('a reload / Back / identity settle (focus false) still resumes the done panel, watch and all', () => {
   const { calls, state } = runEnter({ focus: false, record: REC });
-  assert.deepEqual(calls.show, [[11, false]], 'the done panel, and no focus steal on a non-deliberate arrival');
+  assert.deepEqual(calls.show, [[12, false]], 'the done panel, and no focus steal on a non-deliberate arrival');
   assert.equal(calls.resets, 0, 'nothing is reset — this is the same standup continuing');
   assert.equal(calls.done, 1, 'the checklist is re-rendered');
   assert.deepEqual(calls.progress, ['inst-1'], 'the progress watch is restarted from the record');
@@ -127,7 +127,7 @@ test('…and the standup stays one click away, named, on the resume link', () =>
 
 test('the resume link gets the done panel back — the record was never cleared', () => {
   const { calls, sandbox } = runEnter({ focus: true, resumeIntent: true, record: REC });
-  assert.deepEqual(calls.show, [[11, true]], 'a deliberate resume moves focus to the done panel');
+  assert.deepEqual(calls.show, [[12, true]], 'a deliberate resume moves focus to the done panel');
   assert.deepEqual(calls.progress, ['inst-1'], 'the watch comes back with it');
   assert.equal(sandbox.resumeIntent, false, 'the flag is ONE-SHOT — the next plain nav click must mean "new" again');
   assert.deepEqual(calls.offer, [null], 'and the offer comes down behind it');
@@ -145,20 +145,21 @@ test('a second draft already under way is NOT wiped by navigating back to the wi
 });
 
 test('the done panel\'s own saved step is NOT a second draft — it must not block the reset', () => {
-  // Caught in a render, not in a unit test: show(11) calls saveDraft(), so DRAFT_KEY is
+  // Caught in a render, not in a unit test: show(12) calls saveDraft(), so DRAFT_KEY is
   // non-empty again the moment a create lands. Reading "is there a draft?" left the
   // finished project's name in the fresh form, under a line offering to resume it.
-  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 11, name: 'Mercury' } });
+  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 12, name: 'Mercury' } });
   assert.equal(calls.resets, 1, 'the done step is bookkeeping, not a project being typed');
   assert.deepEqual(calls.show, [[1, false]], 'out-of-range steps land on step 1, the front door');
   assert.equal(state.name, '', 'and the finished project\'s name does not survive into it');
   assert.equal(calls.done, 0, 'never back onto the done panel');
 });
 
-test('a draft on the app step or the review is live too — the last two numbered steps (task 1004351)', () => {
-  // The app step moved the review from 7 to 8, and the front door (task 1004417) to 10. A
-  // guard left behind would reset a second project sitting on its review, silently wiping it.
-  for (const step of [9, 10]) {
+test('a draft on the app step, the Look step or the review is live too — the last three numbered steps (task 1004351)', () => {
+  // The app step moved the review from 7 to 8, the front door (task 1004417) to 10 and the
+  // Look step (task 1004421) to 11. A guard left behind would reset a second project
+  // sitting on its review, silently wiping it.
+  for (const step of [9, 10, 11]) {
     const { calls, state } = runEnter({ focus: true, record: REC, draft: { step } });
     assert.equal(calls.resets, 0, `step ${step} is a live draft`);
     assert.deepEqual(calls.show, [[step, true]]);
@@ -174,8 +175,8 @@ test('a draft on the front door is live too — a founder part-way through it ke
   }
 });
 
-test('a draft whose step is missing or junk resets too — only 1-10 preserves anything', () => {
-  for (const draft of [{ step: 0 }, { step: 11 }, { name: 'half-typed' }]) {
+test('a draft whose step is missing or junk resets too — only 1-11 preserves anything', () => {
+  for (const draft of [{ step: 0 }, { step: 12 }, { name: 'half-typed' }]) {
     const { calls } = runEnter({ focus: true, record: REC, draft });
     assert.equal(calls.resets, 1, `step ${JSON.stringify(draft.step)} is not a wizard step`);
     assert.deepEqual(calls.show, [[1, false]]);