@bongos/core 1.20.58 → 1.20.59

package/release-notes.json

@@ -8465,5 +8465,11 @@
       "id": "1004423",
       "text": "A project that is being founded now has a genesis home at the top of its hall. The founder settles a plan in one click (each stage's length, the starting government by its real name with a plain explanation, and how many passe"
     }
+  ],
+  "1.20.59": [
+    {
+      "id": "1004433",
+      "text": "The profile now knows each person by their own work. An artist's page counts pages approved, how many pages of each part of the site they have tweaked, and what pages earned them; an ideator's counts thoughts filed, how many b"
+    }
   ]
 }

package/scripts/gds/run-unit-tests.js

@@ -155,6 +155,11 @@ const INTEGRATION = new Set([
   // predicate still returns 0 so the bug itself stays executable. Same
   // always-rolled-back transaction discipline as the entry above.
   'session_earnings_mirror_db',
+  // task 1004433: the credits-by-craft split and the per-person earnings
+  // fragment against real SQL. Both are questions about which ledger rows a LIKE
+  // pattern and a LATERAL unnest reach, which a stubbed client cannot answer.
+  // One transaction, always rolled back.
+  'role_stats_db',
   // RENAMED by ADR 0174 (goal 1000068) — these entries said governance_* until task
   // 1003091. A curated set keyed by a stem that no longer exists silently stops
   // covering its file: both of these dropped OUT of the integration set and INTO the

package/src/bongos/db.js

@@ -149,7 +149,27 @@ async function linkAnthropicAccount(builderId, { email, userId }) {
 // updated builder row, or throws { code: 'invalid_discipline', bad } if any
 // element is not offered by this instance.
 
-async function updateBuilderDisciplines(builderId, disciplines) {
+// `mainDiscipline` (task 1004433, core_268) is the builder's own pick of MAIN
+// role, which the canonical-order set cannot carry. Three answers:
+//   undefined  not mentioned: the stored main role is KEPT while it is still in
+//              the new set, and cleared when the builder drops that craft (a main
+//              role they no longer practise would lead their profile otherwise);
+//   null       cleared on purpose;
+//   a string   set, and it must be one of the crafts in the new set
+//              (`invalid_main_discipline`): a main role is one of your roles.
+// The write, spelled once so tests/role_stats_db.mjs runs the very statement
+// against a real Postgres: $3 says whether the caller named a main role at all,
+// $4 is that role (or null to clear it).
+const UPDATE_BUILDER_DISCIPLINES_SQL =
+  `UPDATE builders
+        SET preferred_disciplines = $2,
+            main_discipline = CASE WHEN $3::boolean THEN $4::text
+                                   WHEN main_discipline = ANY($2::text[]) THEN main_discipline
+                                   ELSE NULL END
+      WHERE id = $1
+      RETURNING id, github_id, github_login, display_name, avatar_url, total_credits, karma, created_at, rank, preferred_disciplines, main_discipline`;
+
+async function updateBuilderDisciplines(builderId, disciplines, { mainDiscipline } = {}) {
   const { enabledDisciplines } = require('../modules');
   const offered = enabledDisciplines();
   const list = Array.isArray(disciplines) ? disciplines : [];
@@ -161,12 +181,28 @@ async function updateBuilderDisciplines(builderId, disciplines) {
     throw err;
   }
   const normalized = offered.filter((d) => list.includes(d));
+  if (typeof mainDiscipline === 'string' && !normalized.includes(mainDiscipline)) {
+    const err = new Error(`main discipline ${mainDiscipline} is not one of the chosen disciplines`);
+    err.code = 'invalid_main_discipline';
+    err.bad = [mainDiscipline];
+    throw err;
+  }
+  const setMain = mainDiscipline !== undefined;
   const { rows } = await pool.query(
-    `UPDATE builders
-        SET preferred_disciplines = $2
-      WHERE id = $1
-      RETURNING id, github_id, github_login, display_name, avatar_url, total_credits, karma, created_at, rank, preferred_disciplines`,
-    [builderId, normalized]
+    UPDATE_BUILDER_DISCIPLINES_SQL,
+    [builderId, normalized, setMain, setMain ? mainDiscipline : null]
+  );
+  return rows[0] ?? null;
+}
+
+// The two role facts the profile needs beside the public builder row (task
+// 1004433): the preferred set and the chosen main role. Its own read, rather
+// than a column added to getBuilderById, so the kernel's hot identity read is
+// untouched by a profile feature.
+async function getBuilderRoleChoice(builderId) {
+  const { rows } = await pool.query(
+    `SELECT preferred_disciplines, main_discipline FROM builders WHERE id = $1`,
+    [builderId]
   );
   return rows[0] ?? null;
 }
@@ -1065,6 +1101,8 @@ module.exports = {
   getBuilderByGithubId,
   hasInvitedAccessRequest,
   updateBuilderDisciplines,
+  UPDATE_BUILDER_DISCIPLINES_SQL,
+  getBuilderRoleChoice,
   RANKS,
   setBuilderRank,
   getLatestRankChangeForBuilder,

package/src/bongos/role-stats.js

@@ -0,0 +1,155 @@
+'use strict';
+
+// src/bongos/role-stats.js — EACH ROLE BY ITS OWN WORK: the reads behind the
+// role-shaped 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); RP04 to RP07 draw from this.
+//
+// WHAT IT ANSWERS. For one builder: which of the three crafts they are shown in,
+// which one leads, and each craft's own headline numbers.
+//
+//   engineer  `shipped`, works shipped (unchanged from today), and engineering credits
+//   artist    pages approved, "N of M tweaked" per surface, credits from pages,
+//             this week (copy-desk's studio tally, the `copy-desk.artistStats`
+//             port)
+//   ideator   thoughts filed, ignited, Full Ideas, ratified by the board, total
+//             size across every idea stream with the historical-estimate
+//             marker, and the share still alive (the sky's own reads, the
+//             `ideas.ideatorStats` port)
+//
+// Plus `credits_by_craft`, the ledger split of total_credits (economy's
+// `reward.creditsByCraft`), which is what makes an artist or an ideator who has
+// never shipped a task read as what they are.
+//
+// THE OWNER'S RULES (2026-09-30), and where each lives:
+//   • one person, one profile; the builder CHOOSES their main role
+//     (builders.main_discipline, core_268). Until they do, the main role is the
+//     craft they have earned most in, then their first preferred craft, then
+//     engineering, and `main_basis` says which of those it is, so a surface can
+//     tell a choice from a guess.
+//   • any OTHER role shows only once it has earned credits. `shown` is the main
+//     role first, then each craft with credits, in preferred order. A craft not
+//     in `shown` carries no stats block (null): its tab and chip do not exist.
+//   • decision (a): the identity band, the tally and "By the numbers" stay
+//     public, so everything here is counts and sums. No idea title, no page
+//     wording, no task list leaves this read; those stay behind a sign-in on the
+//     Activity routes. The answer is the same for every viewer.
+//
+// A port that is absent (a vanilla instance without the module) gives that
+// block `null` fields rather than zeros: "could not ask" is not "nothing there".
+
+const seams = require('../module-seams');
+
+const CRAFTS = Object.freeze(['engineer', 'artist', 'ideator']);
+// A discipline as a craft, asked of economy (reward.craftForPreference), the
+// module that decides which craft a credit belongs to. One table, so a builder's
+// chips and their credits cannot disagree (`ui`, the design discipline, is the
+// artist's craft there). With no economy module there are no credits to split
+// either, and only the three craft names read as crafts.
+function craftOf(discipline) {
+  const reward = seams.resolveOptional('reward');
+  if (reward && typeof reward.craftForPreference === 'function') return reward.craftForPreference(discipline);
+  return CRAFTS.includes(discipline) ? discipline : null;
+}
+
+function preferredCrafts(preferred) {
+  const out = [];
+  for (const d of Array.isArray(preferred) ? preferred : []) {
+    const c = craftOf(d);
+    if (c && !out.includes(c)) out.push(c);
+  }
+  return out;
+}
+
+// resolveMainRole — pure. The chosen craft, else the earned one, else the
+// preferred one, else engineering (the platform's default craft).
+function resolveMainRole({ mainDiscipline = null, preferred = [], byCraft = null } = {}) {
+  const chosen = craftOf(mainDiscipline);
+  if (chosen) return { main: chosen, basis: 'chosen' };
+  if (byCraft) {
+    let best = null;
+    for (const c of CRAFTS) {
+      const n = Number(byCraft[c]) || 0;
+      if (n > 0 && (!best || n > best.n)) best = { c, n };
+    }
+    if (best) return { main: best.c, basis: 'earned' };
+  }
+  const pref = preferredCrafts(preferred);
+  if (pref.length) return { main: pref[0], basis: 'preferred' };
+  return { main: 'engineer', basis: 'default' };
+}
+
+// shownCrafts — pure. Main first, then every craft with credits, in the
+// builder's preferred order and then CRAFTS order.
+function shownCrafts({ main, preferred = [], byCraft = null } = {}) {
+  const order = [...preferredCrafts(preferred), ...CRAFTS].filter((c, i, a) => a.indexOf(c) === i);
+  const out = [main];
+  for (const c of order) {
+    if (c === main) continue;
+    if (byCraft && Number(byCraft[c]) > 0) out.push(c);
+  }
+  return out;
+}
+
+// composeRoleStats — pure: the facts in, the profile's `roles` block out.
+function composeRoleStats({ choice = null, byCraft = null, shippedCount = 0, artist = null, ideator = null } = {}) {
+  const preferred = (choice && choice.preferred_disciplines) || [];
+  const { main, basis } = resolveMainRole({ mainDiscipline: choice && choice.main_discipline, preferred, byCraft });
+  const shown = shownCrafts({ main, preferred, byCraft });
+  const credits = byCraft
+    ? { engineer: byCraft.engineer, artist: byCraft.artist, ideator: byCraft.ideator, other: byCraft.other, total: byCraft.total }
+    : null;
+  return {
+    main,
+    main_basis: basis,
+    shown,
+    preferred: preferredCrafts(preferred),
+    credits_by_craft: credits,
+    engineer: shown.includes('engineer')
+      ? { shipped: Number(shippedCount) || 0, credits: credits ? credits.engineer : null }
+      : null,
+    artist: shown.includes('artist') ? (artist || emptyArtist()) : null,
+    ideator: shown.includes('ideator') ? (ideator || emptyIdeator()) : null,
+  };
+}
+
+// The shapes a shown craft takes when its port could not be asked: every number
+// null, so a renderer says "unknown", never "0".
+function emptyArtist() {
+  return { pages_approved: null, pages: null, surfaces_touched: null, credits: null, this_week: null, surfaces: [], unavailable: true };
+}
+function emptyIdeator() {
+  return {
+    filed: null, ignited: null, full_ideas: null, ratified: null,
+    size: { total: null, paid: null, estimated: null, historical: null },
+    alive: { share: null, has_work: null, attributable: null },
+    unavailable: true,
+  };
+}
+
+// readRoleStats — the I/O half. The crafts are decided FIRST, from the ledger,
+// so the heavier per-craft reads run only for a craft that will be shown.
+async function readRoleStats(builderId, { shippedCount = 0, getRoleChoice } = {}) {
+  const reward = seams.resolveOptional('reward');
+  const [choice, byCraftMap] = await Promise.all([
+    getRoleChoice ? getRoleChoice(builderId) : null,
+    reward && typeof reward.creditsByCraft === 'function' ? reward.creditsByCraft([builderId]) : null,
+  ]);
+  const byCraft = byCraftMap ? (byCraftMap.get(String(builderId)) || null) : null;
+  const preferred = (choice && choice.preferred_disciplines) || [];
+  const { main } = resolveMainRole({ mainDiscipline: choice && choice.main_discipline, preferred, byCraft });
+  const shown = shownCrafts({ main, preferred, byCraft });
+
+  const artistPort = shown.includes('artist') ? seams.resolveOptional('copy-desk.artistStats') : null;
+  const ideatorPort = shown.includes('ideator') ? seams.resolveOptional('ideas.ideatorStats') : null;
+  const [artist, ideator] = await Promise.all([
+    typeof artistPort === 'function' ? artistPort(builderId) : null,
+    typeof ideatorPort === 'function' ? ideatorPort(builderId) : null,
+  ]);
+  return composeRoleStats({ choice, byCraft, shippedCount, artist, ideator });
+}
+
+// Only the reader is exported: the pure halves above are reached through it
+// (tests/profile_role_stats.mjs drives them via the real route), and an export
+// nothing imports is dead surface to the knip ratchet.
+module.exports = { readRoleStats };

package/src/bongos/routes/builders.js

@@ -33,6 +33,7 @@ const { validateOrRespond, LIMITS, parseId } = require('./_helpers');
 // for the roster-visible checklist (read/shape) — never a direct require.
 const { pool } = require('../pool');
 const { publicReadRateLimitMiddleware } = require('../middleware/rate-limit');
+const { readRoleStats } = require('../role-stats');
 const seams = require('../../module-seams');
 const { branding } = require('../../branding');
 // The project's stale-claim timer (task 1003476, goal 1000072) — kernel config, so a
@@ -503,6 +504,11 @@ module.exports = function buildBuildersRouter() {
   // monthly_budget_usd / system_role) are NEVER spread into the
   // JSON. A leak-prevention unit test (tests/profile_route.mjs) asserts their
   // absence + the 404-on-unknown-id behaviour.
+  // `roles` (task 1004433) is the one block that is NOT a re-presentation of the
+  // leaderboard: per-craft counts and sums. The owner made them public on
+  // 2026-09-30 (RP01 decision (a): the tally and By the numbers stay public, the
+  // trail, the earnings and every Activity tab need a sign-in), so the block
+  // carries counts only — no idea title, no page wording, no task list.
   // THROTTLED since task 1002804. The global limiter meters WRITES only
   // (rateLimitMiddleware returns early for GET) and the public read limiter is
   // mounted under /public/*, which this is not — so this route answered at line
@@ -535,12 +541,17 @@ module.exports = function buildBuildersRouter() {
       // the same indistinguishable answer cross_project already gives.
       // Optional-chained so an older hub provider without the function degrades
       // to null rather than throwing across a version window.
-      const [shippedCount, recentShips, achievements, crossProject, handle] = await Promise.all([
-        lc().countShippedTasksForBuilder(targetId),
+      const shippedCount = await lc().countShippedTasksForBuilder(targetId);
+      // roles: each craft by its own work (task 1004433 / WA6.RP03) — which
+      // crafts show, which leads, and each one's headline numbers. Counts and
+      // sums only, the same for every viewer: the owner's decision (a) keeps the
+      // tally and By the numbers public and everything under them signed-in.
+      const [recentShips, achievements, crossProject, handle, roles] = await Promise.all([
         lc().recentShippedTasksByBuilder(targetId, 5),
         reward ? reward.getBuilderAchievements(targetId) : [],
         hub ? hub.getPublicProfileExtras(b.github_id) : null,
         hub && hub.getPublicHandle ? hub.getPublicHandle(b.github_id) : null,
+        readRoleStats(targetId, { shippedCount, getRoleChoice: db.getBuilderRoleChoice }),
       ]);
       // WHITELIST — only the leaderboard-equivalent public field set. Never spread
       // the raw row: it carries anthropic_email / anthropic_user_id /
@@ -573,6 +584,7 @@ module.exports = function buildBuildersRouter() {
           shipped_count: shippedCount,
           recent_ships: recentShips,
           achievements,
+          roles,
           cross_project: crossProject,
           handle: handle || null,
         });
@@ -582,6 +594,7 @@ module.exports = function buildBuildersRouter() {
         shipped_count: shippedCount,
         recent_ships: recentShips,
         achievements,
+        roles,
       });
     } catch (err) {
       log.error('[gds] GET /builders/:id/profile', err);

package/src/bongos/routes/me.js

@@ -554,16 +554,24 @@ module.exports = function buildMeRouter() {
   // profile. 422 invalid_discipline if any element is out of range.
   // rank: any-builder — self-service profile edit; documented "no rank gate" in the
   // handler comment above (a builder owns their own preference).
+  // `main_discipline` (optional, task 1004433): the builder's own MAIN role, one
+  // of the crafts in the same body; null clears it, absent keeps it (see
+  // db.updateBuilderDisciplines). 422 invalid_main_discipline otherwise.
   router.patch('/me/disciplines', auth.requireBuilder, async (req, res) => {
     if (validateOrRespond(req, res, {
       preferred_disciplines: { required: true, type: 'array', maxItems: 16, itemsType: 'string' },
+      main_discipline: { type: 'string', maxLength: 32 },
     })) return;
     const input = req.body?.preferred_disciplines;
     if (!Array.isArray(input)) {
       return res.fail('preferred_disciplines must be an array', 400);
     }
+    const body = req.body || {};
+    const mainOpt = Object.prototype.hasOwnProperty.call(body, 'main_discipline')
+      ? { mainDiscipline: body.main_discipline === null ? null : String(body.main_discipline) }
+      : {};
     try {
-      const builder = await db.updateBuilderDisciplines(req.builder.id, input);
+      const builder = await db.updateBuilderDisciplines(req.builder.id, input, mainOpt);
       // The onboarding state machine carved into modules/onboarding/ (BV1.R81 /
       // ADR 0093 §1): resolve the `onboarding` kernel port for the mark + echo —
       // never a direct require of a module. Default-on (present in prod); degrades
@@ -587,8 +595,8 @@ module.exports = function buildMeRouter() {
       const onboarding = onboardingPort ? onboardingPort.shapeForApi(state, { shipCount, discordLinked: !!discordLink, cliAuthed: !!cliAuthed }) : null;
       res.json({ builder, onboarding });
     } catch (err) {
-      if (err.code === 'invalid_discipline') {
-        return res.fail('invalid_discipline', 422, { bad: err.bad });
+      if (err.code === 'invalid_discipline' || err.code === 'invalid_main_discipline') {
+        return res.fail(err.code, 422, { bad: err.bad });
       }
       throw err;
     }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.20.58'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.59'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/copy_desk_page_reads.mjs

@@ -35,7 +35,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)) {
+    if (/FROM pt JOIN tasks t ON t\.id = pt\.id LEFT JOIN task_grades g/.test(q)) {
       assert.match(q, /WHERE t\.source = 'page-tweak'/);
       // The fixture rows stand in for this SELECT, so every column they carry
       // must be one the SELECT really names: a renamed alias would otherwise

package/tests/fixtures/page-ledger.mjs

@@ -188,7 +188,7 @@ export function installPageLedger(api, { builders }) {
       return { rows: db.tasks.filter((t) => t.status === 'shipped' && Date.parse(t.shipped_at) > since && (t.touches || []).some((f) => p[0].includes(f))).map((t) => ({ id: t.id, title: t.title, shipped_at: t.shipped_at })) };
     }
     // The page reads (listPageTweakTasks), computed from the ledger's state.
-    if (/FROM tasks t LEFT JOIN task_grades g/.test(q)) {
+    if (/FROM pt JOIN tasks t ON t\.id = pt\.id LEFT JOIN task_grades g/.test(q)) {
       assert.match(q, /WHERE t\.source = 'page-tweak'/);
       // The optional page scope (task 1004319): $1 is the round-ref prefix or null.
       assert.match(q, /left\(t\.source_ref, length\(\$1::text\)\) = \$1::text/);

package/tests/main_discipline.mjs

@@ -0,0 +1,81 @@
+// tests/main_discipline.mjs — the builder's own MAIN role (task 1004433 /
+// WA6.RP03, core_268): what updateBuilderDisciplines sends for each of the
+// three answers, and what it refuses before anything is written.
+//
+// The statement's own behaviour (keep, clear, set) runs against a real Postgres
+// in tests/role_stats_db.mjs; this pins the half before it, DB-free: the
+// "named or not" flag, the value, and the refusal of a main role that is not
+// one of the builder's chosen crafts.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+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}`); }
+}
+
+const calls = [];
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = {
+  id: poolPath, filename: poolPath, loaded: true,
+  exports: {
+    pool: {
+      async query(sql, params) {
+        calls.push({ sql, params });
+        return { rows: [{ id: params[0], preferred_disciplines: params[1], main_discipline: params[2] ? params[3] : null }] };
+      },
+    },
+  },
+};
+const db = require('../src/bongos/db.js');
+const { enabledDisciplines } = require('../src/modules.js');
+const offered = enabledDisciplines();
+const last = () => calls[calls.length - 1];
+
+await t('the write goes through the one exported statement', async () => {
+  await db.updateBuilderDisciplines(7, ['engineer']);
+  assert.equal(last().sql, db.UPDATE_BUILDER_DISCIPLINES_SQL);
+  assert.match(db.UPDATE_BUILDER_DISCIPLINES_SQL, /main_discipline = CASE WHEN \$3::boolean THEN \$4::text/);
+  assert.match(db.UPDATE_BUILDER_DISCIPLINES_SQL, /WHEN main_discipline = ANY\(\$2::text\[\]\) THEN main_discipline\s+ELSE NULL END/);
+});
+
+await t('not mentioned: the flag is false, so the stored main role is left to the statement to keep or clear', async () => {
+  await db.updateBuilderDisciplines(7, ['engineer', 'ideator']);
+  assert.deepEqual(last().params.slice(2), [false, null]);
+});
+
+await t('named: the flag is true and the role travels', async () => {
+  await db.updateBuilderDisciplines(7, ['ideator', 'engineer'], { mainDiscipline: 'ideator' });
+  assert.deepEqual(last().params.slice(2), [true, 'ideator']);
+  assert.deepEqual(last().params[1], offered.filter((d) => ['ideator', 'engineer'].includes(d)),
+    'the set is still stored in canonical order: the main role is what carries the choice');
+});
+
+await t('null clears it on purpose', async () => {
+  await db.updateBuilderDisciplines(7, ['engineer'], { mainDiscipline: null });
+  assert.deepEqual(last().params.slice(2), [true, null]);
+});
+
+await t('a main role that is not one of the chosen crafts is refused, and nothing is written', async () => {
+  const before = calls.length;
+  await assert.rejects(() => db.updateBuilderDisciplines(7, ['engineer'], { mainDiscipline: 'ideator' }),
+    (err) => err.code === 'invalid_main_discipline' && err.bad[0] === 'ideator');
+  assert.equal(calls.length, before);
+});
+
+await t('the PATCH route hands main_discipline through only when the body names it', async () => {
+  const fs = require('node:fs');
+  const src = fs.readFileSync(require.resolve('../src/bongos/routes/me.js'), 'utf8');
+  const route = src.slice(src.indexOf("router.patch('/me/disciplines'"), src.indexOf("router.patch('/me/disciplines'") + 2500);
+  assert.match(route, /hasOwnProperty\.call\(body, 'main_discipline'\)/);
+  assert.match(route, /db\.updateBuilderDisciplines\(req\.builder\.id, input, mainOpt\)/);
+  assert.match(route, /invalid_main_discipline/);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);