@bongos/core 1.20.58 → 1.20.59

package/modules/economy/credits-by-craft.js

@@ -0,0 +1,208 @@
+'use strict';
+
+// modules/economy/credits-by-craft.js — WHICH CRAFT EARNED A BUILDER'S CREDITS
+// (task 1004433 / WA6.RP03, goal 1000095, criterion wa6-roles-read-true-in-public).
+//
+// WHY. builders.total_credits is one number, and every public surface read it as
+// "payout from shipped work". That is true for an engineer and false for the
+// other two crafts: an artist is paid per approved page (`tweak.page_approved:`),
+// an ideator per idea stream (`idea.credit.*`), and neither has to ship a task to
+// earn. The owner's 2026-09-30 rules need the split: a role other than the main
+// one shows (chip, Activity tab, leaderboard entry) only once it has EARNED
+// credits, and a leaderboard filtered to one role ranks by the credits earned in
+// that craft. So the split is a ledger fact, read here, once.
+//
+// THE RULE, per credit_log row:
+//
+//   tweak.page_approved:<task>          artist   (ADR 0341 D10, the artist lane)
+//   idea.credit.* · idea_promotion_bonus ideator  (ADR 0172, every idea stream,
+//                                                 the spark/developer split too)
+//   task.shipped · task.confirmed ·      the craft of the TASK's discipline
+//   ship.net_negative
+//   session.token_reward                 the craft of the tasks that session
+//                                        shipped, split evenly across them; a
+//                                        session that names none is engineering
+//                                        (an AI build session is, by default)
+//   anything else (achievement.*,        `other` — credited, but to no craft
+//   rank_change, a hand grant)
+//
+// A task's discipline maps to a craft through DISCIPLINE_CRAFT. `ui` is the
+// module-contributed design discipline (ADR 0079, 0272) and counts as ARTIST:
+// the artist's craft is how the project looks and reads (docs/packs/artist.md),
+// and UI design is that. A discipline this table does not know (a module may
+// contribute one later) counts as engineering, the default craft, rather than
+// vanishing from every total.
+//
+// THE SUM IS EXACT. A session's reward split across three tasks is a third each,
+// so the per-craft figures arrive as fractions. They are rounded by LARGEST
+// REMAINDER against the builder's true ledger total, so the crafts and `other`
+// always add up to exactly what the ledger holds. Rounding each craft on its own
+// would let the parts disagree with the whole by a credit, on a page that shows
+// both.
+//
+// ONLY READS. Nothing here writes, and nothing is reachable from a ship path.
+
+const api = require('../../src/module-api');
+const { pool } = api;
+const { ARTIST_PAGE_REASON_PREFIX } = require('./credits');
+
+const CRAFTS = Object.freeze(['engineer', 'artist', 'ideator']);
+const DEFAULT_CRAFT = 'engineer';
+const OTHER = 'other';
+
+const DISCIPLINE_CRAFT = Object.freeze({
+  engineer: 'engineer',
+  artist: 'artist',
+  ui: 'artist',
+  ideator: 'ideator',
+});
+
+// The per-task reasons whose craft is the task's own. The same three the
+// lifecycle's CREDITS_AWARDED_SUBQUERY sums as a task's payout.
+const TASK_REASONS = Object.freeze(['task.shipped', 'task.confirmed', 'ship.net_negative']);
+
+// The craft a builder's PREFERRED discipline names, or null for one that is not
+// a craft at all. The same table, read the other way round: an unknown
+// discipline is engineering money (above) but is no role chip. core's
+// src/bongos/role-stats.js asks this through the reward port, so the ui-is-artist
+// rule has exactly one home.
+function craftForPreference(discipline) {
+  return DISCIPLINE_CRAFT[discipline] || null;
+}
+
+function craftOfDiscipline(discipline) {
+  if (discipline === OTHER) return OTHER;
+  return DISCIPLINE_CRAFT[discipline] || DEFAULT_CRAFT;
+}
+
+// The artist prefix goes into the SQL as a LIKE pattern, so its underscore (a
+// LIKE wildcard) is escaped, the idea-size.js rule. Checked at load: the prefix
+// is economy's own constant, never a request value.
+if (!/^[a-z0-9_.]+:$/i.test(ARTIST_PAGE_REASON_PREFIX)) {
+  throw new Error('economy/credits-by-craft: the artist reason prefix is not a plain literal');
+}
+const ARTIST_LIKE = ARTIST_PAGE_REASON_PREFIX.replace(/([\\%_])/g, '\\$1') + '%';
+
+// One statement for the whole set of builders. Each ledger row becomes one or
+// more (builder, discipline, amount) parts, then they are grouped. The session
+// branch is the only one that fans out: one row per task its session shipped.
+//
+// THE INDEXES IT RIDES, all pre-existing, so this needs no migration: both
+// branches filter `cl.builder_id = ANY($1)`, served by idx_credit_log_builder
+// (builder_id, recorded_at) from migrations/003_pms.sql, so the read is that
+// person's rows, never the whole ledger; the task join is the tasks primary
+// key, and the session join is session_records' UNIQUE (session_id) from
+// migrations/062_session_records.sql. tests/profile_role_stats.mjs pins both
+// index definitions, so dropping either reds a test rather than going quiet.
+const CREDITS_BY_CRAFT_SQL = `
+  WITH parts AS (
+    SELECT cl.builder_id,
+           cl.delta::numeric AS amount,
+           CASE
+             WHEN cl.reason LIKE $2 THEN 'artist'
+             WHEN cl.reason LIKE 'idea.credit.%' OR cl.reason = 'idea_promotion_bonus' THEN 'ideator'
+             WHEN cl.reason = ANY($3::text[]) THEN COALESCE(t.discipline, '${DEFAULT_CRAFT}')
+             ELSE '${OTHER}'
+           END AS discipline
+      FROM credit_log cl
+      LEFT JOIN tasks t ON t.id = cl.task_id
+     WHERE cl.builder_id = ANY($1::bigint[])
+       AND cl.reason <> 'session.token_reward'
+    UNION ALL
+    SELECT cl.builder_id,
+           cl.delta::numeric / GREATEST(COALESCE(cardinality(sr.task_ids), 0), 1) AS amount,
+           COALESCE(st.discipline, '${DEFAULT_CRAFT}') AS discipline
+      FROM credit_log cl
+      LEFT JOIN session_records sr ON sr.session_id = cl.session_id
+      LEFT JOIN LATERAL unnest(COALESCE(sr.task_ids, '{}'::bigint[])) AS u(task_id) ON true
+      LEFT JOIN tasks st ON st.id = u.task_id
+     WHERE cl.builder_id = ANY($1::bigint[])
+       AND cl.reason = 'session.token_reward'
+  )
+  SELECT builder_id, discipline, SUM(amount)::float8 AS amount
+    FROM parts
+   GROUP BY builder_id, discipline`;
+
+// apportion — round fractional parts to integers that sum to `total` exactly
+// (largest remainder; ties go to the earlier key, so the answer is stable).
+// Pure. `parts` is { key: number }, in the order keys should win ties.
+function apportion(parts, total) {
+  const keys = Object.keys(parts);
+  const out = {};
+  let floorSum = 0;
+  const rema = [];
+  keys.forEach((k, i) => {
+    const v = Number(parts[k]) || 0;
+    const f = Math.floor(v);
+    out[k] = f;
+    floorSum += f;
+    rema.push({ k, r: v - f, i });
+  });
+  // When `total` is the rounded sum of the parts (the only way this file calls
+  // it), `left` is round(sum of remainders), so 0 <= left <= keys.length and one
+  // pass hands out every unit.
+  const left = Math.round(Number(total) || 0) - floorSum;
+  rema.sort((a, b) => b.r - a.r || a.i - b.i);
+  for (let j = 0; j < left && j < rema.length; j++) out[rema[j].k] += 1;
+  return out;
+}
+
+// foldCraftRows — the grouped SQL rows into one exact row per builder. Pure,
+// so the rounding and the discipline mapping are testable without a database.
+// Returns Map<builderIdString, { engineer, artist, ideator, other, total }>,
+// with every builder asked for present (at zero when they have earned nothing:
+// "no credits" is an answer, not a gap).
+function foldCraftRows(ids, rows) {
+  const raw = new Map();
+  for (const id of ids) {
+    const parts = {};
+    for (const c of CRAFTS) parts[c] = 0;
+    parts[OTHER] = 0;
+    raw.set(id, parts);
+  }
+  for (const r of rows || []) {
+    const parts = raw.get(String(r.builder_id));
+    if (!parts) continue;
+    parts[craftOfDiscipline(r.discipline)] += Number(r.amount) || 0;
+  }
+  const out = new Map();
+  for (const [id, parts] of raw) {
+    const total = Math.round(Object.values(parts).reduce((a, b) => a + b, 0));
+    out.set(id, { ...apportion(parts, total), total });
+  }
+  return out;
+}
+
+function idOf(v) {
+  return /^[1-9]\d*$/.test(String(v)) ? String(v) : null;
+}
+
+// creditsByCraft — the split for MANY builders in ONE query. The leaderboard's
+// role toggle (RP07) asks for a page of builders at once, the profile for one.
+async function creditsByCraft(builderIds, { client = null } = {}) {
+  const ids = [...new Set((Array.isArray(builderIds) ? builderIds : [builderIds]).map(idOf).filter(Boolean))];
+  if (ids.length === 0) return new Map();
+  const q = client || pool;
+  const { rows } = await q.query(CREDITS_BY_CRAFT_SQL, [ids, ARTIST_LIKE, TASK_REASONS]);
+  return foldCraftRows(ids, rows);
+}
+
+// The crafts a builder has EARNED in, in CRAFTS order. The owner's rule is that
+// a role other than the main one shows only once it has earned credits; this is
+// the "has earned" half, and the only place it is decided.
+function earnedCrafts(row) {
+  if (!row) return [];
+  return CRAFTS.filter((c) => Number(row[c]) > 0);
+}
+
+module.exports = {
+  creditsByCraft,
+  foldCraftRows,
+  apportion,
+  craftOfDiscipline,
+  craftForPreference,
+  earnedCrafts,
+  CRAFTS,
+  DISCIPLINE_CRAFT,
+  CREDITS_BY_CRAFT_SQL,
+};

package/modules/economy/reward.js

@@ -22,6 +22,7 @@ const streak = require('./streak');
 const ideaSizeLib = require('./idea-size');
 const ideaSizeHistorical = require('./idea-size-historical');
 const ideaBrightnessLib = require('./idea-brightness');
+const creditsByCraftLib = require('./credits-by-craft');
 
 module.exports = {
   // credit allocation — transaction-participant: caller passes its tx `client`
@@ -125,6 +126,13 @@ module.exports = {
   // still alive.
   ideaBrightness: (...a) => ideaBrightnessLib.ideaBrightness(...a),
   ideaBrightnesses: (...a) => ideaBrightnessLib.ideaBrightnesses(...a),
+  // WHICH CRAFT EARNED IT (task 1004433 / WA6.RP03). total_credits split into
+  // engineer / artist / ideator / other, exact to the ledger. The profile reads
+  // it to decide which roles show; the leaderboard's role toggle ranks by it.
+  creditsByCraft: (...a) => creditsByCraftLib.creditsByCraft(...a),
+  earnedCrafts: (...a) => creditsByCraftLib.earnedCrafts(...a),
+  craftForPreference: (...a) => creditsByCraftLib.craftForPreference(...a),
+  get CRAFTS() { return creditsByCraftLib.CRAFTS; },
   computeStreak: (...a) => streak.computeStreak(...a),
   wouldExtendStreak: (...a) => streak.wouldExtendStreak(...a),
 };

package/modules/hall-ui/public/hall-render.js

@@ -510,8 +510,8 @@
       ? `+${fmtNum(karma30d)} in 30d`
       : (karma30d < 0 ? `${fmtNum(karma30d)} in 30d` : '±0 in 30d');
     const karmaTrend = `<span class="karma-badge__trend ${signClasses(karma30d, 'karma-badge__trend')}">${karmaTrendText}</span>`;
-    const karmaTooltip = `Karma = peer recognition and approvals. ${curLabel(true)} = work shipped. The two counters move independently — see the karma feed for the audit trail.`;
-    const drachmaeTooltip = `${curLabel(true)} = total payout from shipped work. Karma is a separate counter for peer recognition and approvals.`;
+    const karmaTooltip = `Karma = peer recognition and approvals. ${curLabel(true)} = everything earned. The two counters move independently — see the karma feed for the audit trail.`;
+    const drachmaeTooltip = `${curLabel(true)} = everything earned: shipped work, approved pages and ideas. Karma is a separate counter for peer recognition and approvals.`;
 
     // V3.R84 (#302), criterion C3: monthly-budget banner. `warn` (>=80%) is a
     // heads-up; `over` (>=100%) means cost-incurring actions (ship, art pipeline)

package/modules/hall-ui/public/profile.js

@@ -105,7 +105,7 @@
         ${disciplines}
       </div>
       <div class="profile__credits">
-        <span class="profile__credits-num" title="${escapeHtml(curLabel(true))} — total payout from shipped work.">${fmtNum(builder.total_credits)}</span>
+        <span class="profile__credits-num" title="${escapeHtml(curLabel(true))} — everything earned: shipped work, approved pages and ideas.">${fmtNum(builder.total_credits)}</span>
         <span class="profile__credits-label">${escapeHtml(curLabel())}</span>
         <span class="profile__karma" title="Karma — peer recognition and approvals, a separate counter from ${escapeHtml(curLabel())}.">
           <span class="profile__karma-num">${fmtNum(builder.karma)}</span>

package/modules/ideas/ideator-stats.js

@@ -0,0 +1,149 @@
+'use strict';
+
+// modules/ideas/ideator-stats.js — THE IDEATOR'S NUMBERS for the profile
+// (task 1004433 / WA6.RP03, goal 1000095, criterion wa6-roles-read-true-in-public;
+// the owner-approved mock is docs/design/mocks/profile-roles/, task 1004431).
+//
+// The profile's header and "By the numbers" lead with each person's own craft.
+// For an ideator that is six numbers, and every one of them is a COUNT or a SUM
+// over the sky's own derivation, never a second one:
+//
+//   filed      thoughts filed (the person's trail, skill-friction rows left out)
+//   ignited    thoughts that became paid work (state.hasWork, the sky's ignition)
+//   full       Full Ideas (grade 'full')
+//   ratified   Full Ideas the Board Room carried (government.boardPassForIdea)
+//   size       credits earned from ideas across EVERY idea stream, plus the
+//              historical estimate, with the marker that says so
+//   alive      the share of the work their thoughts caused that is still alive
+//
+// WHERE EACH COMES FROM. The trail is `readSkyMine` (./sky-mine.js), which walks
+// the whole trail and runs the three attachers in the trail route's order, so a
+// thought's size, brightness and state here are the ones the sky draws. Nothing
+// in this file derives a state.
+//
+// SIZE IS EVERY STREAM, NOT STREAM 1. A thought's drawn size is its stream-1
+// payout (economy/idea-size.js: the work it caused). The PERSON's total is a
+// different question, "what has thinking earned you", and the owner's mock
+// answers it across every way ideas are paid: the task ship and its descent, the
+// Full Idea pass, the board pass and the spark/developer split. That is the
+// ledger's ideator column (economy/credits-by-craft.js, through the `reward`
+// port), so the headline agrees with the earnings chart to the credit. The
+// historical estimate (spec decision 17) rides on top, from the per-thought
+// sizes the sky already priced: money the ledger was never there to pay, so it
+// is reported apart as `size.estimated` and marked, never folded in silently.
+//
+// ALIVE IS WEIGHTED BY SIZE, like a single thought's brightness: the live
+// credits over all credits, across every thought that ignited. A thought that
+// could not be read (`attributable: false`) makes the whole share unknown
+// (null) rather than quietly counting it as alive, and a person whose thoughts
+// caused nothing yet has no share at all (null, `has_work: false`): zero over
+// zero is not "nothing survived". The two nulls are told apart by `has_work`.
+//
+// PUBLIC BY THE OWNER'S DECISION (a) of 2026-09-30: the identity band, the
+// tally and "By the numbers" stay public, the trail itself does not. So these
+// are counts and sums only. No title, no id, no triage note leaves this file,
+// and the read is the same for every viewer: the skill-friction gate is applied
+// at the least-privileged real rank, because those rows are a routine's
+// filings, not a person's thoughts, and a count must not change with who looks.
+
+const api = require('../../src/module-api');
+const { readSkyMine } = require('./sky-mine');
+
+// The rank the counts are read at. xenos is the one rank the skill-friction gate
+// hides those rows from (./skill-friction.js); reading at it makes the public
+// count the count of the person's own thoughts.
+const PUBLIC_VIEWER_RANK = 'xenos';
+
+function int(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? Math.round(n) : 0;
+}
+
+// summarizeIdeatorTrail — the six numbers from a trail that already carries
+// size and state. Pure. `ideatorCredits` is the ledger's ideator column (null
+// when economy could not be asked), `ratifiedIds` the set of idea ids the board
+// carried (null when the government port is absent).
+function summarizeIdeatorTrail(ideas, { ideatorCredits = null, ratifiedIds = null, truncated = false, total = null } = {}) {
+  const list = Array.isArray(ideas) ? ideas : [];
+  let ignited = 0;
+  let full = 0;
+  let ratified = 0;
+  let estimated = 0;
+  let estimateKnown = true;
+  let credits = 0;
+  let live = 0;
+  let attributable = true;
+  for (const idea of list) {
+    if (!idea) continue;
+    const st = idea.state || {};
+    if (st.hasWork === true) ignited++;
+    if (idea.grade === 'full') {
+      full++;
+      if (ratifiedIds && ratifiedIds.has(String(idea.id))) ratified++;
+    }
+    const size = idea.size;
+    if (!size) { estimateKnown = false; continue; }
+    if (size.estimated == null) estimateKnown = false;
+    else estimated += int(size.estimated);
+    if (st.hasWork === true) {
+      const c = Number(size.credits) || 0;
+      credits += c;
+      if (st.attributable !== true || st.brightness == null) attributable = false;
+      else live += c * Number(st.brightness);
+    }
+  }
+  const paid = ideatorCredits == null ? null : int(ideatorCredits);
+  const est = estimateKnown ? estimated : null;
+  return {
+    // The trail's own count, not the page in hand: past the sky's cap the list
+    // is the newest thousand and `truncated` says the other numbers are partial.
+    filed: Number.isInteger(total) ? total : list.length,
+    ignited,
+    full_ideas: full,
+    ratified: ratifiedIds ? ratified : null,
+    size: {
+      total: paid == null ? null : paid + (est || 0),
+      paid,
+      estimated: est,
+      historical: est == null ? null : est > 0,
+    },
+    alive: {
+      share: credits > 0 && attributable ? live / credits : null,
+      has_work: credits > 0,
+      attributable: credits > 0 ? attributable : null,
+    },
+    truncated: truncated === true,
+  };
+}
+
+// readIdeatorStats — the async half: the trail, the ledger column, the board.
+// `deps` lets a test hand in each port; production resolves them optionally, so
+// an instance without economy or the board reads `null` for those numbers
+// (could not ask) rather than 0 (asked, and nothing was there).
+async function readIdeatorStats(builderId, deps = {}) {
+  const read = deps.readSkyMine || readSkyMine;
+  const reward = 'reward' in deps ? deps.reward : (api.resolveOptional && api.resolveOptional('reward'));
+  const government = 'government' in deps ? deps.government : (api.resolveOptional && api.resolveOptional('government'));
+
+  const sky = await read({ builderId, viewerRank: PUBLIC_VIEWER_RANK });
+  const ideas = (sky && sky.ideas) || [];
+
+  let ideatorCredits = null;
+  if (reward && typeof reward.creditsByCraft === 'function') {
+    const byCraft = await reward.creditsByCraft([builderId]);
+    const row = byCraft.get(String(builderId));
+    ideatorCredits = row ? row.ideator : 0;
+  }
+
+  let ratifiedIds = null;
+  if (government && typeof government.boardPassForIdea === 'function') {
+    ratifiedIds = new Set();
+    const fulls = ideas.filter((i) => i && i.grade === 'full');
+    const passes = await Promise.all(fulls.map((i) => government.boardPassForIdea(i.id)));
+    fulls.forEach((i, k) => { if (passes[k]) ratifiedIds.add(String(i.id)); });
+  }
+
+  return summarizeIdeatorTrail(ideas, { ideatorCredits, ratifiedIds, truncated: sky && sky.truncated, total: sky && sky.total });
+}
+
+module.exports = { readIdeatorStats, summarizeIdeatorTrail, PUBLIC_VIEWER_RANK };

package/modules/ideas/module.json

@@ -21,7 +21,8 @@
   },
   "provides": [
     "ideas.capture",
-    "ideas.descent"
+    "ideas.descent",
+    "ideas.ideatorStats"
   ],
   "consumes": [
     "reward",

package/modules/ideas/routes/inbox.js

@@ -36,6 +36,7 @@ const express = require('express');
 const api = require('../../../src/module-api');
 const inbox = require('../inbox');
 const bornOf = require('../born-of');
+const ideatorStats = require('../ideator-stats');
 // The trail read to the FULL depth of the descent (task 1004089, BV2.R09). Its
 // own file because inbox.js is AT the size ratchet and because a task->task
 // walk is a different relation from the idea->task trail.
@@ -108,6 +109,12 @@ function registerSeams() {
       descendantsOfTask: descent.descendantsOfTask,
     });
   }
+  // task 1004433 (WA6.RP03): the ideator's numbers for the profile, counts and
+  // sums only, so core's profile route can show them without reading an ideas_
+  // table or deriving a state (../ideator-stats.js).
+  if (!api.hasProvider('ideas.ideatorStats')) {
+    api.registerProvider('ideas.ideatorStats', ideatorStats.readIdeatorStats);
+  }
 }
 
 // The author-facing shape of a ratification window this request just opened —

package/modules/lifecycle/activity.js

@@ -36,7 +36,10 @@
 const api = require('../../src/module-api');
 const { pool } = api;
 const { SMOKE_NOT_LIKE } = require('./db-shared.js');
-const { CREDITS_AWARDED_SUBQUERY } = require('./db-tasks.js');
+// What THIS person was paid for each row, not the task's whole payout (task
+// 1004433): on a page tweak the artist and the applier are two people's pay, and
+// under cost-plus-only the per-task estimate books nothing at all.
+const { creditsEarnedBySql } = require('./db-tasks.js');
 
 // The craft vocabulary this read accepts. Mirrors tasks_discipline_check
 // (migrations 086 + 176). Anything else is treated as "no filter" rather than
@@ -97,7 +100,7 @@ async function activityTasksByBuilder(builderId, { role = null, limit = DEFAULT_
     `SELECT t.id, t.title, t.value_summary, t.visual_url, t.visual_alt,
             t.version_id, t.goal_id, t.kind, t.status, t.shipped_at,
             COALESCE(t.discipline, 'unclassified') AS discipline,
-            t.credits_reward, ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded
+            t.credits_reward, ${creditsEarnedBySql('$1')} AS credits_awarded
        FROM tasks t
       WHERE ${where}
       ORDER BY t.shipped_at DESC NULLS LAST, t.id DESC

package/modules/lifecycle/db-analytics.js

@@ -13,7 +13,7 @@
 const api = require('../../src/module-api');
 const { pool, withTx } = api;
 const { SMOKE_NOT_LIKE, gradePassCount, gradeQualityWhere, median } = require('./db-shared.js');
-const { CREDITS_AWARDED_SUBQUERY } = require('./db-tasks.js');
+const { CREDITS_AWARDED_SUBQUERY, creditsEarnedBySql } = require('./db-tasks.js');
 const { helperJoinSql } = require('./page-tweak-artist.js');
 
 // -------------------------------------------------------------------------
@@ -137,8 +137,10 @@ async function estimationDriftSummary() {
 
 async function recentShippedTasksByBuilder(builderId, limit = 10) {
   const { rows } = await pool.query(
+    // task 1004433: the profile's recent works show what THIS builder was paid
+    // (creditsEarnedBySql), not the task's whole payout across everyone.
     `SELECT t.id, t.title, t.value_summary, t.visual_url, t.visual_alt, t.version_id, t.status, t.shipped_at, t.credits_reward,
-            ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded
+            ${creditsEarnedBySql('$1')} AS credits_awarded
        FROM tasks t
       WHERE t.shipped_by = $1
         AND t.status = 'shipped'

package/modules/lifecycle/db-tasks.js

@@ -676,14 +676,61 @@ async function updateTaskModuleKey(id, moduleKey) { return updateTaskColumn(id,
 // CASE still short-circuits to 0 for unsettled tasks; note a 'confirmed' task
 // now shows 0 until it LANDS (the credit no longer exists at confirm) — the UI
 // renders the "Est." label until the 'task.shipped' row books at land.
+//
+// task 1004433 (WA6.RP03): the allowlist missed two of the per-task streams, so
+// an approved page read "0 credits" and an idea's payout for the task it caused
+// never counted. Both are booked against the task's own id and are payment FOR
+// that task: `tweak.page_approved:<task>` (the artist lane, ADR 0341 D10, paid
+// INSTEAD of the per-task estimate) and every `idea.credit.*` row carrying this
+// task_id (stream 1 and its descent, ADR 0172 / 0312). Streams 2 and 3 carry no
+// task_id and stay out, as they pay for the thought, not for any task. Matched
+// as prefixes, never by equality: each key embeds the ids it was paid for.
+const TASK_PAYOUT_REASON_SQL =
+  `(cl.reason IN ('task.confirmed', 'task.shipped', 'idea_promotion_bonus', 'ship.net_negative')
+                   OR cl.reason LIKE 'tweak.page\\_approved:%'
+                   OR cl.reason LIKE 'idea.credit.%')`;
 const CREDITS_AWARDED_SUBQUERY =
   `CASE WHEN t.status IN ('confirmed', 'shipped')
         THEN (SELECT COALESCE(SUM(cl.delta), 0)::int
                 FROM credit_log cl
                WHERE cl.task_id = t.id
-                 AND cl.reason IN ('task.confirmed', 'task.shipped', 'idea_promotion_bonus', 'ship.net_negative'))
+                 AND ${TASK_PAYOUT_REASON_SQL})
         ELSE 0 END`;
 
+// creditsEarnedBySql — what ONE person earned for a task, for the lists that
+// say "this is what <person> was paid" (the profile's recent works and its
+// Activity tab). CREDITS_AWARDED_SUBQUERY above is the TASK's payout across
+// everyone, which was the wrong number there twice over: on a page tweak the
+// artist's page credit and the applier's session reward are two people's pay,
+// and under cost-plus-only (ADR 0146) the per-task estimate books nothing, so a
+// builder who was paid normally read 0 on every row.
+//
+// Two halves, the two attribution keys sumSessionEarnings names (task 1003634):
+//   • every per-task payout row this builder holds against the task;
+//   • the cost-plus SESSION reward (task_id NULL, keyed by session) for each of
+//     this builder's sessions that shipped the task, split evenly across the
+//     tasks that session shipped. The session pays for its whole token spend,
+//     not for one task, so an even share is the honest per-task figure.
+// `builderRef` is a bound parameter reference such as '$1', never a value.
+// session_records is read through idx_session_records_builder.
+function creditsEarnedBySql(builderRef) {
+  if (!/^\$\d+$/.test(builderRef)) throw new Error('creditsEarnedBySql: builderRef must be a bind parameter like $1');
+  return `CASE WHEN t.status IN ('confirmed', 'shipped')
+        THEN (COALESCE((SELECT SUM(cl.delta)
+                          FROM credit_log cl
+                         WHERE cl.task_id = t.id
+                           AND cl.builder_id = ${builderRef}
+                           AND ${TASK_PAYOUT_REASON_SQL}), 0)
+            + COALESCE((SELECT ROUND(SUM(cl.delta::numeric / GREATEST(cardinality(sr.task_ids), 1)))
+                          FROM session_records sr
+                          JOIN credit_log cl ON cl.session_id = sr.session_id
+                                            AND cl.reason = 'session.token_reward'
+                                            AND cl.builder_id = ${builderRef}
+                         WHERE sr.builder_id = ${builderRef}
+                           AND t.id = ANY(sr.task_ids)), 0))::int
+        ELSE 0 END`;
+}
+
 async function getTask(id) {
   const { rows } = await pool.query(
     `SELECT t.*, ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded,
@@ -1343,6 +1390,7 @@ async function listOpenArtistReviews({ source, refPrefix, resolvedStatuses = [],
 
 module.exports = {
   CREDITS_AWARDED_SUBQUERY,
+  creditsEarnedBySql,
   REWARD_SUGGESTION_CAP,
   createCriterion,
   createTask,

package/modules/lifecycle/db.js

@@ -123,15 +123,16 @@ const {
 // the next setter costs nothing.
 //
 // TASK_FACADE_OMIT is what keeps this surface-PRESERVING rather than quietly
-// wider. Two of db-tasks.js's 33 exports were deliberately never re-exported
+// wider. Three of db-tasks.js's 34 exports were deliberately never re-exported
 // here, and a bare spread would publish them — which ADR 0091 §3 treats as a
 // real surface change, not a tidy-up. Naming them means dropping one has to be
 // somebody's decision. tests/lifecycle_facade_surface.mjs pins the resulting key
 // set, so this can never silently widen or narrow.
 const dbTasks = require('./db-tasks.js');
 const TASK_FACADE_OMIT = new Set([
-  // Internal to db-tasks.js's own queries — a SQL fragment, not a callable.
+  // Internal to the lifecycle's own queries — SQL fragments, not callables.
   'CREDITS_AWARDED_SUBQUERY',
+  'creditsEarnedBySql',
   // The version-gate predicate; routes reach it through db-versions, not here.
   'versionAcceptsNewWork',
 ]);

package/modules/lifecycle/page-tweak-reads.js

@@ -45,11 +45,27 @@ const artistRule = require('./page-tweak-artist');
 // autosave runs this on every debounced save, and a page's rounds are a handful
 // while the instance's grow without bound. The prefix is matched with left(),
 // not LIKE, the page claim's own rule (an `_` in an id is never a wildcard).
-async function listPageTweakTasks({ pageId = null } = {}) {
+//
+// `artistId` narrows it to ONE artist's rounds (task 1004433 / WA6.RP03): the
+// profile's artist numbers read this on a public page, and an artist's rounds
+// are a handful while the instance's grow without bound. The rounds are found
+// FROM that builder's own web claims (claims by builder_id), never by listing
+// every round and filtering, and a round counts only while its LATEST web
+// claim is still theirs: the D10 payee rule the unscoped read applies.
+// `client` lets a caller run it inside its own transaction (tests/role_stats_db.mjs
+// runs the artist branch against real Postgres, rolled back); default the pool.
+async function listPageTweakTasks({ pageId = null, artistId = null, client = null } = {}) {
   const prefix = pageId ? `page-tweak/${pageId}/` : null;
-  const { rows } = await api.pool.query(
+  const artist = artistId == null ? null : String(artistId);
+  const { rows } = await (client || api.pool).query(
     `WITH pt AS (
-       SELECT t.id FROM tasks t WHERE t.source = 'page-tweak'
+       SELECT t.id FROM tasks t WHERE $2::bigint IS NULL AND t.source = 'page-tweak'
+          AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
+       UNION
+       SELECT t.id FROM claims c JOIN tasks t ON t.id = c.task_id
+        WHERE $2::bigint IS NOT NULL AND c.builder_id = $2::bigint
+          AND ${artistRule.webClaimPredicate('c')}
+          AND t.source = 'page-tweak'
           AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
      ), web AS (
        SELECT DISTINCT ON (c.task_id) c.task_id, c.builder_id
@@ -63,7 +79,8 @@ async function listPageTweakTasks({ pageId = null } = {}) {
             ac.builder_id AS holder_id, hb.github_login AS holder_login,
             (ac.worktree_name IS NOT NULL) AS holder_worktree,
             wc.builder_id AS artist_id, ab.github_login AS artist_login
-       FROM tasks t
+       FROM pt
+       JOIN tasks t ON t.id = pt.id
        LEFT JOIN task_grades g ON g.task_id = t.id
        LEFT JOIN claims ac ON ac.task_id = t.id AND ac.released_at IS NULL
        LEFT JOIN builders hb ON hb.id = ac.builder_id
@@ -71,8 +88,9 @@ async function listPageTweakTasks({ pageId = null } = {}) {
        LEFT JOIN builders ab ON ab.id = wc.builder_id
       WHERE t.source = 'page-tweak'
         AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
+        AND ($2::bigint IS NULL OR wc.builder_id = $2::bigint)
       ORDER BY t.id ASC`,
-    [prefix]
+    [prefix, artist]
   );
   return rows;
 }

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.58",
+  "version": "1.20.59",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.20.58",
+      "version": "1.20.59",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.58",
+  "version": "1.20.59",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",