@bongos/core 1.20.57 → 1.20.59

package/tests/profile_role_stats.mjs

@@ -0,0 +1,416 @@
+// tests/profile_role_stats.mjs — WA6.RP03 (task 1004433): each role read by its
+// own work, behind the role-shaped profile (the owner-approved mock is
+// docs/design/mocks/profile-roles/, task 1004431).
+//
+// DONE WHEN: "the three reads are correct for fixtures of each craft, including
+// an ideator and an artist who have never shipped a task". So the centre of this
+// file is three people the mock already names, driven through the REAL profile
+// route (GET /builders/:id/profile) with the REAL role composer, the REAL
+// ideator summary over states the REAL resolver derived, the REAL artist read
+// over the REAL page inventory, and economy's REAL fold of the ledger rows:
+//
+//   Ines Varga   an artist who has never shipped a task: pages and ideas only
+//   Tobi Rahn    an ideator who has never shipped a task: thoughts only
+//   Mara Okonkwo an engineer, who also earned a little from an idea
+//
+// The SQL halves (which ledger rows the classification and the per-person
+// earnings reach) run against a real Postgres in tests/role_stats_db.mjs; here
+// the ledger answers with the grouped rows that SQL returns, and everything from
+// there to the JSON is the production path.
+//
+// Also pinned: the public answer carries counts only (decision (a)), the main
+// role's fallbacks, the exact apportioning, and the unknown-not-zero rule when a
+// port is missing.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+// ---- the people ------------------------------------------------------------
+
+const INES = 201; const TOBI = 202; const MARA = 203; const NEW = 204; const UI = 205; const LEA = 206;
+const ROWS = {
+  [INES]: { id: INES, github_login: 'ines', display_name: 'Ines Varga', total_credits: 312, karma: 0, rank: 'thetes', preferred_disciplines: ['artist', 'ideator'], main_discipline: null },
+  [TOBI]: { id: TOBI, github_login: 'tobi', display_name: 'Tobi Rahn', total_credits: 186, karma: 0, rank: 'thetes', preferred_disciplines: ['ideator'], main_discipline: null },
+  [MARA]: { id: MARA, github_login: 'mara', display_name: 'Mara Okonkwo', total_credits: 2480, karma: 118, rank: 'metic', preferred_disciplines: ['engineer', 'ideator'], main_discipline: 'engineer' },
+  [NEW]: { id: NEW, github_login: 'new', display_name: 'Newcomer', total_credits: 0, karma: 0, rank: 'xenos', preferred_disciplines: [], main_discipline: null },
+  [UI]: { id: UI, github_login: 'priya', display_name: 'Priya Das', total_credits: 60, karma: 0, rank: 'metic', preferred_disciplines: ['engineer', 'ui'], main_discipline: 'ui' },
+  [LEA]: { id: LEA, github_login: 'lea', display_name: 'Lea Brandt', total_credits: 30, karma: 0, rank: 'thetes', preferred_disciplines: ['artist'], main_discipline: null },
+};
+const SHIPPED = { [INES]: 0, [TOBI]: 0, [MARA]: 64, [NEW]: 0, [UI]: 2, [LEA]: 0 };
+
+// What CREDITS_BY_CRAFT_SQL returns, grouped by (builder, discipline). Ines's
+// session reward was split across two tasks of different crafts, so her rows
+// arrive as halves; the fold has to make them exact again.
+const LEDGER_ROWS = [
+  { builder_id: String(INES), discipline: 'artist', amount: 120 },
+  { builder_id: String(INES), discipline: 'ideator', amount: 42 },
+  { builder_id: String(INES), discipline: 'engineer', amount: 74.5 },
+  { builder_id: String(INES), discipline: 'ui', amount: 74.5 },
+  { builder_id: String(INES), discipline: 'other', amount: 1 },
+  { builder_id: String(TOBI), discipline: 'ideator', amount: 186 },
+  { builder_id: String(MARA), discipline: 'engineer', amount: 2460 },
+  { builder_id: String(MARA), discipline: 'ideator', amount: 20 },
+  { builder_id: String(UI), discipline: 'ui', amount: 60 },
+  // a discipline nobody mapped yet counts as engineering, never vanishes
+  { builder_id: String(UI), discipline: 'some-module-craft', amount: 0 },
+];
+
+// ---- the page-tweak ledger (Ines and one other artist) ----------------------
+
+const pages = require('../modules/copy-desk/pages.js');
+const inventory = require('../docs/page-inventory.json');
+const onSurface = (s) => inventory.pages.filter((p) => p.surface === s).map((p) => p.id);
+const LANDING = onSurface('landing');
+const BUILDERS = onSurface('builders');
+const NOW = new Date();
+const DAY = 24 * 60 * 60 * 1000;
+const PAGE_WORDS = 'DO_NOT_LEAK_PAGE_WORDING';
+let tid = 9000;
+const round = (pageId, n, artistId, status) => ({
+  id: String(++tid), source: 'page-tweak', source_ref: pages.roundSourceRef(pageId, n), status, artist_id: String(artistId),
+  description: `\`\`\`page-tweak\n${PAGE_WORDS}\n\`\`\``, title: `Tweak: ${PAGE_WORDS}`,
+});
+const PAGE_TASKS = [
+  round(LANDING[0], 1, INES, 'shipped'),
+  round(LANDING[0], 2, INES, 'shipped'),   // the same page twice: two approvals, one page
+  round(LANDING[1], 1, INES, 'shipped'),
+  round(BUILDERS[0], 1, INES, 'shipped'),
+  round(BUILDERS[1], 1, INES, 'ready'),    // still being written: not approved
+  round(BUILDERS[2], 1, LEA, 'shipped'),   // someone else's page
+];
+const PAGE_CREDITS = {
+  [INES]: [
+    { reason: `tweak.page_approved:${PAGE_TASKS[0].id}`, delta: 30, recorded_at: new Date(NOW - 20 * DAY).toISOString() },
+    { reason: `tweak.page_approved:${PAGE_TASKS[1].id}`, delta: 30, recorded_at: new Date(NOW - 10 * DAY).toISOString() },
+    { reason: `tweak.page_approved:${PAGE_TASKS[2].id}`, delta: 30, recorded_at: new Date(NOW - 2 * DAY).toISOString() },
+    { reason: `tweak.page_approved:${PAGE_TASKS[3].id}`, delta: 30, recorded_at: new Date(NOW - 1 * DAY).toISOString() },
+  ],
+  [LEA]: [{ reason: `tweak.page_approved:${PAGE_TASKS[5].id}`, delta: 30, recorded_at: NOW.toISOString() }],
+};
+
+// ---- the idea trails, with states derived by the REAL resolver ---------------
+
+const { resolveIdeaState } = require('../modules/ideas/idea-state.js');
+const IDEA_WORDS = 'DO_NOT_LEAK_IDEA_TITLE';
+function thought(id, { status = 'open', grade = 'quick', credits = 0, estimated = 0, share = 1, attributable = true } = {}) {
+  const hasWork = credits > 0;
+  return {
+    id: String(id), title: `${IDEA_WORDS} ${id}`, triage_note: IDEA_WORDS, status, grade,
+    size: { credits, paid: credits - estimated, estimated, payments: hasWork ? 1 : 0, byTask: new Map() },
+    state: resolveIdeaState({ status, hasWork, share: hasWork ? share : 1, attributable, tasks: [] }),
+  };
+}
+const TRAILS = {
+  [TOBI]: [
+    thought(1, { grade: 'full', credits: 64, share: 1 }),
+    thought(2, { grade: 'full', credits: 42, share: 0.6 }),
+    thought(3),
+    thought(4, { credits: 18 }),
+    thought(5, { credits: 22, estimated: 10, share: 0 }),      // burned out; part of it historical
+    thought(6, { status: 'merged' }),
+    thought(7, { status: 'discarded' }),
+    thought(8, { grade: 'full', credits: 26, share: 0.85 }),
+  ],
+  [INES]: [thought(21, { credits: 42 }), thought(22), thought(23), thought(24)],
+  [MARA]: [thought(31, { credits: 20 })],
+};
+const RATIFIED = new Set(['1']);
+const skyCalls = [];
+const pageReads = [];
+
+// ---- the harness: real route, real composer, ports at their real seams -------
+
+const authPath = require.resolve('../src/bongos/auth.js');
+require.cache[authPath] = {
+  id: authPath, filename: authPath, loaded: true,
+  exports: {
+    requireBuilder: (_req, _res, next) => next(),
+    requirePermission: () => (_req, _res, next) => next(),
+    requireRank: () => (_req, _res, next) => next(),
+  },
+};
+const dbPath = require.resolve('../src/bongos/db.js');
+require.cache[dbPath] = {
+  id: dbPath, filename: dbPath, loaded: true,
+  exports: {
+    RANKS: ['xenos', 'thetes', 'metic', 'archon'],
+    getBuilderById: async (id) => (ROWS[id] ? { ...ROWS[id], created_at: '2026-07-01T00:00:00.000Z', avatar_url: null } : null),
+    getBuilderRoleChoice: async (id) => (ROWS[id]
+      ? { preferred_disciplines: ROWS[id].preferred_disciplines, main_discipline: ROWS[id].main_discipline }
+      : null),
+  },
+};
+
+const seams = require('../src/module-seams.js');
+seams._reset();
+const creditsByCraftLib = require('../modules/economy/credits-by-craft.js');
+const ledgerSql = [];
+const ledgerClient = {
+  async query(sql, params) {
+    ledgerSql.push({ sql, params });
+    const ids = new Set(params[0].map(String));
+    return { rows: LEDGER_ROWS.filter((r) => ids.has(r.builder_id)) };
+  },
+};
+seams.registerProvider('lifecycle', {
+  countShippedTasksForBuilder: async (id) => SHIPPED[id] || 0,
+  recentShippedTasksByBuilder: async () => [],
+  // Honours the artist scope the way the SQL does (only rounds whose latest web
+  // claim is theirs), and records it, so the read is held to asking for one
+  // artist rather than every round in the project.
+  listPageTweakTasks: async (opts = {}) => {
+    pageReads.push(opts);
+    return PAGE_TASKS.filter((r) => opts.artistId == null || r.artist_id === String(opts.artistId)).map((r) => ({ ...r }));
+  },
+});
+seams.registerProvider('reward', {
+  getBuilderAchievements: async () => [],
+  creditsByCraft: (ids) => creditsByCraftLib.creditsByCraft(ids, { client: ledgerClient }),
+  craftForPreference: (d) => creditsByCraftLib.craftForPreference(d),
+  creditLedger: async (builderId, { reasonPrefix }) => {
+    const rows = (PAGE_CREDITS[builderId] || []).filter((r) => r.reason.startsWith(reasonPrefix));
+    return { rows, total: rows.length };
+  },
+});
+seams.registerProvider('government', { boardPassForIdea: async (id) => (RATIFIED.has(String(id)) ? { outcome: 'passed' } : null) });
+const ideatorStats = require('../modules/ideas/ideator-stats.js');
+seams.registerProvider('ideas.ideatorStats', (id) => ideatorStats.readIdeatorStats(id, {
+  readSkyMine: async ({ builderId, viewerRank }) => {
+    skyCalls.push({ builderId, viewerRank });
+    const ideas = TRAILS[builderId] || [];
+    return { ideas, total: ideas.length, truncated: false };
+  },
+}));
+// The copy-desk router's factory is the production registration of its port.
+require('../modules/copy-desk/routes/copy-desk.js')();
+assert.equal(typeof seams.resolveOptional('copy-desk.artistStats'), 'function', 'copy-desk registers its read port at boot');
+
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildBuildersRouter = require('../src/bongos/routes/builders.js');
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use('/api/bongos', buildBuildersRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const port = server.address().port;
+function get(path) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({ host: '127.0.0.1', port, method: 'GET', path }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        resolve({ status: res.statusCode, json: JSON.parse(text), text });
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+const profile = async (id) => {
+  const r = await get(`/api/bongos/builders/${id}/profile`);
+  assert.equal(r.status, 200, r.text);
+  return r;
+};
+
+// ---- the artist who has never shipped a task --------------------------------
+
+await t('ARTIST, never shipped: leads with artist, by what she earned, and shows ideator beside it', async () => {
+  const { json } = await profile(INES);
+  assert.equal(json.shipped_count, 0, 'the fixture is the case the task names: no shipped task at all');
+  const r = json.roles;
+  assert.equal(r.main, 'artist');
+  assert.equal(r.main_basis, 'earned', 'no main role chosen yet, so it is inferred and says so');
+  assert.deepEqual(r.shown, ['artist', 'ideator', 'engineer'],
+    'main first, then every craft she EARNED in, in her preferred order (her session reward was part engineering)');
+  assert.equal(r.engineer.shipped, 0);
+});
+
+await t('ARTIST: pages approved, pages, N of M per surface, credits from pages and this week', async () => {
+  const a = (await profile(INES)).json.roles.artist;
+  assert.equal(a.pages_approved, 4, 'four approved rounds, each one paid');
+  assert.equal(a.pages, 3, 'on three distinct pages (one was tweaked twice)');
+  assert.equal(a.surfaces_touched, 2);
+  assert.equal(a.credits, 120, 'credits from pages are the page rows only, not her other pay');
+  assert.equal(a.this_week, 60, 'two approvals inside the trailing week');
+  const landing = a.surfaces.find((s) => s.id === 'landing');
+  const builders = a.surfaces.find((s) => s.id === 'builders');
+  assert.equal(landing.tweaked, 2);
+  assert.equal(landing.total, LANDING.length, 'M is the surface page count, the studio denominator');
+  assert.equal(landing.line, `2 of ${LANDING.length} tweaked`);
+  assert.equal(builders.tweaked, 1, 'her unapproved draft and the other artist page do not count');
+  assert.equal(builders.total, BUILDERS.length);
+  assert.equal(a.inventory_known, true);
+  assert.deepEqual(pageReads[pageReads.length - 1], { artistId: INES }, 'one artist rounds, never the whole project');
+});
+
+await t('the credit split is exact: halves rounded by largest remainder, ui folded into artist', async () => {
+  const c = (await profile(INES)).json.roles.credits_by_craft;
+  assert.deepEqual(c, { engineer: 75, artist: 194, ideator: 42, other: 1, total: 312 },
+    '74.5 + 74.5 must not round to 150 or 148; the parts equal the whole');
+  assert.equal(c.engineer + c.artist + c.ideator + c.other, c.total);
+});
+
+// ---- the ideator who has never shipped a task -------------------------------
+
+await t('IDEATOR, never shipped: leads with ideator, shows nothing it did not earn', async () => {
+  const { json } = await profile(TOBI);
+  assert.equal(json.shipped_count, 0);
+  assert.equal(json.roles.main, 'ideator');
+  assert.deepEqual(json.roles.shown, ['ideator']);
+  assert.equal(json.roles.engineer, null, 'no engineering block for someone with no engineering credit');
+  assert.equal(json.roles.artist, null);
+});
+
+await t('IDEATOR: filed, ignited, Full Ideas, ratified, total size every stream + the estimate marker, still alive', async () => {
+  const i = (await profile(TOBI)).json.roles.ideator;
+  assert.equal(i.filed, 8);
+  assert.equal(i.ignited, 5, 'the five that were paid for work, a burned-out one included');
+  assert.equal(i.full_ideas, 3);
+  assert.equal(i.ratified, 1, 'the one the board carried');
+  assert.deepEqual(i.size, { total: 196, paid: 186, estimated: 10, historical: true },
+    'the ledger ideator column (every stream) plus the historical estimate, marked');
+  const expected = (64 * 1 + 42 * 0.6 + 18 + 22 * 0 + 26 * 0.85) / (64 + 42 + 18 + 22 + 26);
+  assert.ok(Math.abs(i.alive.share - expected) < 1e-9, `size-weighted live share, got ${i.alive.share}`);
+  assert.equal(i.alive.has_work, true);
+  assert.equal(i.truncated, false);
+});
+
+await t('the trail is read at the public rank, so a count never changes with who is looking', async () => {
+  skyCalls.length = 0;
+  await profile(TOBI);
+  assert.deepEqual(skyCalls, [{ builderId: TOBI, viewerRank: 'xenos' }]);
+});
+
+// ---- the engineer ------------------------------------------------------------
+
+await t('ENGINEER: unchanged headline (works shipped), chosen main role, a little ideator beside it', async () => {
+  const r = (await profile(MARA)).json.roles;
+  assert.equal(r.main, 'engineer');
+  assert.equal(r.main_basis, 'chosen');
+  assert.deepEqual(r.shown, ['engineer', 'ideator']);
+  assert.deepEqual(r.engineer, { shipped: 64, credits: 2460 });
+  assert.equal(r.artist, null, 'no page read for someone with no artist credit');
+  assert.equal(r.ideator.filed, 1);
+  assert.equal(r.ideator.size.paid, 20);
+});
+
+// ---- the fallbacks and the boundary ------------------------------------------
+
+await t('main role: a chosen ui reads as artist; nothing chosen and nothing earned is engineering, said to be a default', async () => {
+  const ui = (await profile(UI)).json.roles;
+  assert.equal(ui.main, 'artist');
+  assert.equal(ui.main_basis, 'chosen');
+  assert.deepEqual(ui.preferred, ['engineer', 'artist']);
+  const nobody = (await profile(NEW)).json.roles;
+  assert.equal(nobody.main, 'engineer');
+  assert.equal(nobody.main_basis, 'default');
+  assert.deepEqual(nobody.shown, ['engineer']);
+  assert.equal(nobody.credits_by_craft.total, 0, 'zero credits is an answer, not a gap');
+});
+
+await t('decision (a): the public answer is counts and sums, never an idea title or a word of a page', async () => {
+  for (const id of [INES, TOBI, MARA]) {
+    const { text } = await profile(id);
+    assert.ok(!text.includes(IDEA_WORDS), 'no idea title or triage note on the public profile');
+    assert.ok(!text.includes(PAGE_WORDS), 'no page wording on the public profile');
+  }
+});
+
+await t('a missing port reads as unknown (null), never as zero', async () => {
+  const ideasPort = seams.resolveOptional('ideas.ideatorStats');
+  seams._reset();
+  seams.registerProvider('lifecycle', { countShippedTasksForBuilder: async () => 0, recentShippedTasksByBuilder: async () => [] });
+  seams.registerProvider('reward', { getBuilderAchievements: async () => [], creditsByCraft: (ids) => creditsByCraftLib.creditsByCraft(ids, { client: ledgerClient }) });
+  try {
+    const r = (await profile(TOBI)).json.roles;
+    assert.equal(r.ideator.filed, null);
+    assert.equal(r.ideator.unavailable, true);
+  } finally {
+    seams.registerProvider('ideas.ideatorStats', ideasPort);
+  }
+});
+
+// ---- the pure halves ----------------------------------------------------------
+
+await t('apportion hands out exactly the rounding left over, larger remainder first, ties to the earlier key', () => {
+  assert.deepEqual(creditsByCraftLib.apportion({ a: 1.5, b: 1.5, c: 0 }, 3), { a: 2, b: 1, c: 0 });
+  assert.deepEqual(creditsByCraftLib.apportion({ a: 0.2, b: 0.7, c: 0.1 }, 1), { a: 0, b: 1, c: 0 });
+  assert.deepEqual(creditsByCraftLib.apportion({ a: 10, b: 0 }, 10), { a: 10, b: 0 });
+});
+
+await t('the ledger statement classifies by reason, splits the session reward and escapes the artist prefix', () => {
+  const sql = creditsByCraftLib.CREDITS_BY_CRAFT_SQL;
+  assert.match(sql, /cl\.reason LIKE \$2 THEN 'artist'/);
+  assert.match(sql, /idea\.credit\.%' OR cl\.reason = 'idea_promotion_bonus' THEN 'ideator'/);
+  assert.match(sql, /GREATEST\(COALESCE\(cardinality\(sr\.task_ids\), 0\), 1\)/, 'an even split, and a session that shipped nothing still counts once');
+  const last = ledgerSql[ledgerSql.length - 1];
+  assert.equal(last.params[1], 'tweak.page\\_approved:%', 'the underscore is escaped, so it is not a LIKE wildcard');
+  assert.deepEqual(last.params[2], ['task.shipped', 'task.confirmed', 'ship.net_negative']);
+});
+
+await t('the craft split reads one person rows through existing indexes, never the whole ledger', () => {
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const mig = (f) => fs.readFileSync(path.join(path.dirname(require.resolve('../package.json')), 'migrations', f), 'utf8');
+  assert.match(mig('003_pms.sql'), /CREATE INDEX IF NOT EXISTS idx_credit_log_builder ON credit_log \(builder_id, recorded_at\)/,
+    'credit_log is indexed by builder: the WHERE cl.builder_id = ANY($1) in both branches is an index read');
+  assert.match(mig('062_session_records.sql'), /session_id\s+text NOT NULL UNIQUE/, 'the session join is a unique-index probe');
+  const sql = creditsByCraftLib.CREDITS_BY_CRAFT_SQL;
+  assert.equal((sql.match(/WHERE cl\.builder_id = ANY\(\$1::bigint\[\]\)/g) || []).length, 2, 'both branches are scoped to the builders asked for');
+});
+
+await t('the per-person fragment only takes a bind reference, and the task payout counts the artist and idea rows', () => {
+  const { creditsEarnedBySql, CREDITS_AWARDED_SUBQUERY } = require('../modules/lifecycle/db-tasks.js');
+  assert.throws(() => creditsEarnedBySql('1; DROP TABLE tasks'), /bind parameter/);
+  const frag = creditsEarnedBySql('$3');
+  assert.match(frag, /cl\.builder_id = \$3/);
+  assert.match(frag, /sr\.builder_id = \$3/);
+  assert.match(frag, /cl\.reason = 'session\.token_reward'/);
+  assert.match(CREDITS_AWARDED_SUBQUERY, /tweak\.page\\_approved:%/);
+  assert.match(CREDITS_AWARDED_SUBQUERY, /idea\.credit\.%/);
+  assert.doesNotMatch(CREDITS_AWARDED_SUBQUERY, /achievement/);
+});
+
+await t('the profile lists read what THIS person earned, not the task payout', () => {
+  const fs = require('node:fs');
+  const activity = fs.readFileSync(require.resolve('../modules/lifecycle/activity.js'), 'utf8');
+  const analytics = fs.readFileSync(require.resolve('../modules/lifecycle/db-analytics.js'), 'utf8');
+  assert.match(activity, /\$\{creditsEarnedBySql\('\$1'\)\} AS credits_awarded/);
+  const byBuilder = analytics.slice(analytics.indexOf('async function recentShippedTasksByBuilder'));
+  assert.match(byBuilder.slice(0, 1200), /\$\{creditsEarnedBySql\('\$1'\)\} AS credits_awarded/);
+});
+
+await t('the artist-scoped page read starts from that builder web claims and keeps the latest-web-claim rule', () => {
+  const fs = require('node:fs');
+  const src = fs.readFileSync(require.resolve('../modules/lifecycle/page-tweak-reads.js'), 'utf8');
+  const fn = src.slice(src.indexOf('async function listPageTweakTasks'), src.indexOf('async function shippedTasksTouchingSince'));
+  assert.match(fn, /FROM claims c JOIN tasks t ON t\.id = c\.task_id\s+WHERE \$2::bigint IS NOT NULL AND c\.builder_id = \$2::bigint/,
+    'an artist rounds are found from their own claims, not by listing every round');
+  assert.match(fn, /wc\.builder_id = \$2::bigint/, 'and a round counts only while its latest web claim is still theirs');
+  assert.match(fn, /\[prefix, artist\]/);
+});
+
+await t('summarizeIdeatorTrail: no work is no share (not zero), an unreadable thought makes the share unknown', () => {
+  const none = ideatorStats.summarizeIdeatorTrail([thought(1), thought(2)], { ideatorCredits: 0, ratifiedIds: new Set() });
+  assert.deepEqual(none.alive, { share: null, has_work: false, attributable: null });
+  const blind = ideatorStats.summarizeIdeatorTrail([thought(1, { credits: 5, attributable: false })], { ideatorCredits: 5, ratifiedIds: null });
+  assert.equal(blind.alive.share, null);
+  assert.equal(blind.alive.attributable, false);
+  assert.equal(blind.ratified, null, 'no board port: ratified is unknown, not zero');
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

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.