@bongos/core 1.20.51 → 1.20.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.51",
+  "version": "1.20.53",
   "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",

package/release-notes.json

@@ -8419,5 +8419,21 @@
       "id": "1004430",
       "text": "Hall navigation is more standard. The top bar now has a Back button when you open a page from inside another one. A builder's profile opened from the Builders list shows \"Back to Builders\" and returns you to the same spot in t"
     }
+  ],
+  "1.20.52": [
+    {
+      "id": "1004425",
+      "text": "The project-startup flow now has its five life-stage pictures, one per stage of a new project's genesis: a primordial sea, first cells, a genome, a membrane and a nervous system, each in the chrome world's style with a dark an"
+    },
+    {
+      "id": "1004475",
+      "text": "Equity or shares is now also greyed out for a single-owner company and for a research entity, each with its own short reason. Only a regular for-profit company or a division of a corporation is offered equity. As before, it's"
+    }
+  ],
+  "1.20.53": [
+    {
+      "id": "1004432",
+      "text": "An approved page now counts as the artist's own work everywhere the project shows who did what: their profile, their shipped count, their activity, the status page and the leaderboard. Before, the page was credited to the sess"
+    }
   ]
 }

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.51'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.53'; // 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/genesis_life_plates.mjs

@@ -0,0 +1,63 @@
+// tests/genesis_life_plates.mjs — the five genesis life-stage plates (task 1004425 /
+// BV2.PS12, goal 1000121).
+//
+// One plate per genesis stage, shipped as the world's pair: a black-ground JPEG for
+// dark mode and an alpha WebP cutout for light, each with the provenance sidecar every
+// world plate carries. The genesis home's life strip (the GenesisHall mock today, the
+// live genesis home in PS08) reads them by these names, so a renamed or half-shipped
+// pair breaks the strip silently: a missing image is an empty square, not an error.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const WORLD = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
+const MOCK = path.join(ROOT, 'docs', 'design', 'mocks', 'project-startup', 'GenesisHall.dc.html');
+
+// The stages in genesis order, with the label the strip captions them by.
+const PLATES = [
+  ['scope', 'primordial sea', 'r5-life-1-primordial-sea'],
+  ['strategize', 'first cells', 'r5-life-2-first-cells'],
+  ['charter', 'the genome', 'r5-life-3-genome'],
+  ['legalize', 'the membrane', 'r5-life-4-membrane'],
+  ['legislation', 'the nervous system', 'r5-life-5-nervous-system'],
+];
+
+// The first bytes of each format, so a mislabelled file (a PNG saved as .jpg) fails here.
+const isJpeg = (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff;
+const isWebp = (b) => b.toString('ascii', 0, 4) === 'RIFF' && b.toString('ascii', 8, 12) === 'WEBP';
+
+test('each genesis stage ships the world pair: a dark JPEG and a light WebP cutout', () => {
+  for (const [, , slug] of PLATES) {
+    const jpg = fs.readFileSync(path.join(WORLD, `${slug}.jpg`));
+    const cut = fs.readFileSync(path.join(WORLD, `${slug}-cut.webp`));
+    assert.ok(isJpeg(jpg), `${slug}.jpg is a JPEG`);
+    assert.ok(isWebp(cut), `${slug}-cut.webp is a WebP`);
+  }
+});
+
+test('every plate file carries a provenance sidecar naming its stage and label', () => {
+  for (const [stage, label, slug] of PLATES) {
+    for (const [file, kind] of [[`${slug}.jpg`, 'plate'], [`${slug}-cut.webp`, 'cutout']]) {
+      const side = JSON.parse(fs.readFileSync(path.join(WORLD, `${file}.json`), 'utf8'));
+      assert.equal(side.kind, kind, `${file}: kind`);
+      assert.equal(side.task, 1004425, `${file}: task`);
+      assert.equal(side.stage, stage, `${file}: stage`);
+      assert.equal(side.label, label, `${file}: label`);
+      assert.ok(side.prompt && side.model, `${file}: prompt and model recorded`);
+    }
+  }
+});
+
+test('the genesis mock life strip shows all five plates and no placeholder', () => {
+  const html = fs.readFileSync(MOCK, 'utf8');
+  assert.ok(!/plate to render/.test(html), 'no "plate to render" placeholder left');
+  for (const [stage, label, slug] of PLATES) {
+    const tile = html.split('\n').find((l) => l.includes(`<p class="cap">${stage}<b>${label}</b>`));
+    assert.ok(tile, `a tile for ${stage}`);
+    assert.ok(tile.includes(`/assets/world/${slug}-cut.webp`), `${stage} tile uses ${slug}`);
+  }
+});

package/tests/page_tweak_artist.mjs

@@ -0,0 +1,236 @@
+// tests/page_tweak_artist.mjs
+//
+// Task 1004432 / WA6.RP02: an approved page tweak counts as the ARTIST's work,
+// not the applier's.
+//
+// The fixture round the task's DONE WHEN names: artist A writes the page (a WEB
+// claim), session B applies it (a CLI claim in a worktree), A approves. Through
+// the REAL db.shipTask over a small stateful ledger:
+//   * the shipped row names A (tasks.shipped_by), not B, even though confirm had
+//     already attributed it to B;
+//   * the onboarding count, first_ship_at and the achievement reconcile follow A;
+//   * A's credit is the one artist row it always was, and B is paid nothing more;
+//   * an ordinary task and a round with no web claim keep their shipper;
+//   * before the round ships, shipped_by still names B, so the rebase gate keeps
+//     asking the session that can do the rebase.
+// Then the READERS, run for real against the ledger: A's profile works, shipped
+// count, activity and the status page's recent list show the page as A's, and
+// B's do not count it; the recent list names B as the helper.
+// And the one rule: the helper's predicate is the one economy pays on, the one
+// the Tweak Mode reads use, and the one the backfill migration spells out.
+//
+// Run:  node tests/page_tweak_artist.mjs
+
+import { strict as assert } from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+const achievements = require('../modules/economy/achievements.js');
+achievements.evaluateAfterShip = async () => [];
+achievements.evaluateAfterCreditAward = async () => [];
+const reconciled = [];
+achievements.reconcileBuilderAchievements = async (_client, builderId) => { reconciled.push(String(builderId)); return []; };
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+const api = require('../src/module-api.js');
+const db = require('../modules/lifecycle/db.js');
+const activity = require('../modules/lifecycle/activity.js');
+const rule = require('../modules/lifecycle/page-tweak-artist.js');
+
+const { test, summary } = makeRunner();
+
+const A = '41'; // the artist
+const B = '42'; // the applier
+const RECONCILER = '999';
+const LAND_PROOF = { kind: 'proof', reason: 'test fixture: land proven' };
+const norm = (s) => String(s).replace(/\s+/g, ' ').trim();
+
+const web = (builder, at) => ({ builder_id: builder, claimed_at: at, worktree_name: null, creator_session_id: null });
+const cli = (builder, at) => ({ builder_id: builder, claimed_at: at, worktree_name: `tw-${builder}-${at}`, creator_session_id: `s-${builder}` });
+
+// A one-task ledger. The ship UPDATE is evaluated from the SQL it is sent: the
+// page-tweak branch takes the artist only when the statement actually carries
+// the helper's artist subquery, so reverting db-ship.js to a plain COALESCE
+// makes the shipped row keep B and this file red.
+function ledger({ source = 'page-tweak', shippedBy = B, claims = [web(A, 1), cli(B, 2)] } = {}) {
+  const state = {
+    task: { id: 7001, title: 'Tweak: Home (landing:index)', source, status: 'confirmed', credits_reward: 30, kind: 'feature', shipped_by: shippedBy },
+    claims: claims.map((c, i) => ({ id: 9000 + i, ...c })),
+    credit_log: [], firstShip: [], counted: [],
+  };
+  const latest = (list) => list.slice().sort((x, y) => (x.claimed_at - y.claimed_at) || (x.id - y.id)).slice(-1)[0] || null;
+  const artistSubquery = norm(rule.artistIdSql('tasks.id'));
+  const pool = makeSqlAwareClient((s, p) => {
+    const t = state.task;
+    if (/^UPDATE tasks SET status = 'shipped'/.test(s)) {
+      if (t.status !== 'confirmed') return { rows: [] };
+      t.status = 'shipped';
+      const pageBranch = s.includes(`CASE WHEN source = '${rule.PAGE_TWEAK_SOURCE}' THEN COALESCE(${artistSubquery}, shipped_by, $2)`);
+      const w = latest(state.claims.filter((c) => c.worktree_name == null && c.creator_session_id == null));
+      t.shipped_by = (pageBranch && t.source === 'page-tweak' && w) ? w.builder_id : (t.shipped_by ?? p[1]);
+      return { rows: [{ id: t.id, title: t.title, status: 'shipped', shipped_at: new Date().toISOString(), shipped_by: t.shipped_by,
+        security_sensitive: false, value_summary: null, credits_reward: t.credits_reward, kind: t.kind, source: t.source }] };
+    }
+    if (/^UPDATE claims/.test(s)) return { rows: [] };
+    if (/^UPDATE builders SET first_ship_at/.test(s)) { state.firstShip.push(String(p[0])); return { rows: [] }; }
+    if (/^SELECT count\(\*\)::int AS n FROM tasks WHERE shipped_by = \$1/.test(s)) { state.counted.push(String(p[0])); return { rows: [{ n: 1 }] }; }
+    if (/^SELECT builder_id FROM claims WHERE task_id = \$1/.test(s)) {
+      const c = latest(state.claims);
+      return { rows: c ? [{ builder_id: c.builder_id }] : [] };
+    }
+    if (/^SELECT t\.source, t\.status, t\.credits_reward, t\.kind/.test(s)) {
+      const w = latest(state.claims.filter((c) => c.worktree_name == null && c.creator_session_id == null));
+      return { rows: [{ source: t.source, status: t.status, credits_reward: t.credits_reward, kind: t.kind, artist_id: w ? w.builder_id : null }] };
+    }
+    if (/^INSERT INTO credit_log/.test(s)) {
+      const [builder_id, task_id, delta, reason] = p;
+      if (state.credit_log.some((r) => r.task_id === task_id && r.reason === reason)) return { rows: [], rowCount: 0 };
+      state.credit_log.push({ builder_id: String(builder_id), task_id, delta, reason });
+      return { rows: [], rowCount: 1 };
+    }
+    return { rows: [] };
+  });
+  return { pool, state };
+}
+
+const ship = (pool) => db.shipTask({ taskId: 7001, builderId: RECONCILER, landAssurance: LAND_PROOF }, { pool });
+
+// =========================================================================
+await test('A writes, B applies, A approves: the shipped row names A, not B', async () => {
+  reconciled.length = 0;
+  const { pool, state } = ledger();
+  assert.equal(state.task.shipped_by, B, 'precondition: confirm attributed the round to the applier');
+  const out = await ship(pool);
+  assert.equal(String(out.shipped_by), A, 'the author of record is the artist');
+  assert.equal(String(state.task.shipped_by), A);
+  assert.deepEqual(state.firstShip, [A], 'first_ship_at is stamped on the artist');
+  assert.ok(state.counted.every((id) => id === A) && state.counted.length > 0, 'the ship count that drives onboarding is the artist\'s');
+  assert.deepEqual(reconciled, [A], 'the achievements this ship can unlock are the artist\'s');
+});
+
+await test('A\'s credits are unchanged: one artist row of 30, nothing to B', async () => {
+  const { pool, state } = ledger();
+  await ship(pool);
+  assert.deepEqual(state.credit_log.map((r) => [r.builder_id, r.delta, r.reason]), [[A, 30, 'tweak.page_approved:7001']]);
+  assert.ok(!state.credit_log.some((r) => r.builder_id === B), 'the applier is paid nothing on the land');
+});
+
+await test('a self-applied round names its one author', async () => {
+  const { pool, state } = ledger({ shippedBy: A, claims: [web(A, 1), cli(A, 2)] });
+  await ship(pool);
+  assert.equal(String(state.task.shipped_by), A);
+});
+
+await test('a round with no web claim keeps its applier; an ordinary task keeps its shipper', async () => {
+  const noWeb = ledger({ claims: [cli(B, 2)] });
+  await ship(noWeb.pool);
+  assert.equal(String(noWeb.state.task.shipped_by), B, 'no artist on record: the applier stays');
+  const ordinary = ledger({ source: null, claims: [web(A, 1), cli(B, 2)] });
+  await ship(ordinary.pool);
+  assert.equal(String(ordinary.state.task.shipped_by), B, 'an ordinary task is never re-attributed, web claim or not');
+});
+
+await test('the rewrite happens only at the shipped flip: confirm still names the applier', () => {
+  const src = readFileSync(new URL('../modules/lifecycle/db-ship.js', import.meta.url), 'utf8');
+  const confirmUpdate = src.slice(src.indexOf('async function confirmTask'));
+  assert.match(confirmUpdate, /shipped_by = COALESCE\(shipped_by, \$2\)/, 'confirmTask attributes to the claim holder, unchanged');
+  for (const f of ['db-grade.js', 'db-overrides.js']) {
+    const s = readFileSync(new URL(`../modules/lifecycle/${f}`, import.meta.url), 'utf8');
+    assert.ok(!s.includes('artistIdSql'), `${f} confirms; it must not move attribution before the round ships`);
+  }
+  assert.match(src, /WHERE needs_rebase = true AND status = 'confirmed' AND shipped_by = \$1/, 'the rebase gate still reads the confirmed row\'s shipper');
+});
+
+// =========================================================================
+// The readers, for real. A shipped page tweak is now a row whose shipped_by is
+// A; every reader below must key on shipped_by for that to reach the person.
+const shippedRow = { id: 7001, title: 'Tweak: Home (landing:index)', value_summary: 'Home reads in the artist\'s words', visual_url: null, visual_alt: null,
+  version_id: 'BONGOS-V2', goal_id: null, kind: 'feature', status: 'shipped', shipped_at: '2026-09-30T12:00:00Z', discipline: 'artist',
+  credits_reward: 30, credits_awarded: 30, source: 'page-tweak', shipped_by: A, github_login: 'artist-a', display_name: 'Artist A',
+  helper_login: 'applier-b', helper_display_name: 'Applier B' };
+const readerSql = [];
+api.pool.query = async (sql, params = []) => {
+  const s = norm(sql);
+  readerSql.push(s);
+  const mine = /shipped_by = \$1/.test(s) ? String(params[0]) === A : true;
+  if (/^SELECT count\(\*\)::int AS (n|total) FROM tasks/.test(s)) return { rows: [{ n: mine ? 1 : 0, total: mine ? 1 : 0 }] };
+  return { rows: mine ? [shippedRow] : [] };
+};
+
+await test('A\'s profile works, shipped count and activity hold the page; B\'s do not', async () => {
+  assert.equal((await db.recentShippedTasksByBuilder(A)).length, 1, 'A\'s profile lists the page');
+  assert.equal((await db.recentShippedTasksByBuilder(B)).length, 0, 'B\'s profile does not');
+  assert.equal(await db.countShippedTasksForBuilder(A), 1);
+  assert.equal(await db.countShippedTasksForBuilder(B), 0, 'B\'s shipped count does not count it');
+  assert.equal((await activity.activityTasksByBuilder(A)).total, 1, 'A\'s activity holds it');
+  assert.equal((await activity.activityTasksByBuilder(B)).total, 0, 'B\'s activity does not');
+  assert.ok((await activity.activityTasksByBuilder(A, { role: 'artist' })).total === 1, 'and under the Artist craft');
+});
+
+await test('the status page\'s recent list shows the page as A\'s, with B as the helper', async () => {
+  readerSql.length = 0;
+  const rows = await db.recentShippedTasks(30);
+  assert.equal(rows[0].github_login, 'artist-a');
+  const sql = readerSql[0];
+  assert.match(sql, /LEFT JOIN builders b ON b\.id = t\.shipped_by/, 'the shipper column is the author of record');
+  assert.ok(sql.includes(norm(rule.helperJoinSql('t'))), 'the helper is the shared join, not a second derivation');
+  assert.match(sql, /helper\.helper_login, helper\.helper_display_name/);
+});
+
+await test('the helper join names only a DIFFERENT applier, and only on a page tweak', () => {
+  const j = norm(rule.helperJoinSql('t'));
+  assert.match(j, /t\.source = 'page-tweak'/, 'never on an ordinary task');
+  assert.match(j, /c\.worktree_name IS NOT NULL/, 'the applier is the worktree claim');
+  assert.match(j, /ap\.builder_id IS DISTINCT FROM t\.shipped_by/, 'a self-applied round names no helper');
+  assert.match(j, /WHERE t\.source = 'page-tweak' AND c\.task_id = t\.id/, 'the source test guards the claims scan itself, so an ordinary row reads no claim');
+  const idx = readFileSync(new URL('../migrations/core_263_closeness_history_indexes.sql', import.meta.url), 'utf8');
+  assert.match(idx, /CREATE INDEX IF NOT EXISTS idx_claims_task_all\s+ON claims \(task_id\)/, 'a page tweak\'s per-row lookup is an index probe');
+});
+
+await test('the status page and the acclaim feed render the helper', () => {
+  const status = readFileSync(new URL('../modules/status-ui/public/status.js', import.meta.url), 'utf8');
+  assert.match(status, /t\.helper_display_name \|\| t\.helper_login/);
+  assert.match(status, /with help from \$\{helper\}/);
+  const hall = readFileSync(new URL('../modules/hall-ui/public/builders.js', import.meta.url), 'utf8');
+  assert.match(hall, /with help from \$\{escapeHtml\(helperName\)\}/, 'escaped before it reaches innerHTML');
+  const feed = readFileSync(new URL('../modules/lifecycle/routes/tasks.js', import.meta.url), 'utf8');
+  assert.match(feed, /helper\.helper_login, helper\.helper_display_name/, 'the acclaim feed carries the helper');
+});
+
+await test('session upload coverage skips page tweaks: an artist runs no session', () => {
+  const s = readFileSync(new URL('../modules/sessions/db.js', import.meta.url), 'utf8');
+  const n = (s.match(/AND t\.source IS DISTINCT FROM 'page-tweak'/g) || []).length;
+  assert.equal(n, 2, 'both the coverage verdict and the missing-record list');
+});
+
+// =========================================================================
+// ONE RULE. Economy cannot require the lifecycle helper, so its copy of the
+// predicate is held to the helper's here; so are the Tweak Mode reads and the
+// backfill migration.
+await test('economy pays the same artist the ship now names', () => {
+  const credits = norm(readFileSync(new URL('../modules/economy/credits.js', import.meta.url), 'utf8'));
+  assert.ok(credits.includes(`WHERE c.task_id = t.id AND ${rule.webClaimPredicate('c')} ORDER BY ${rule.latestFirst('c')} LIMIT 1`),
+    'awardArtistPageCredit reads the payee by the helper\'s predicate and order');
+});
+
+await test('the Tweak Mode reads take the predicate from the helper, not a literal', () => {
+  const reads = readFileSync(new URL('../modules/lifecycle/page-tweak-reads.js', import.meta.url), 'utf8');
+  assert.match(reads, /\$\{artistRule\.webClaimPredicate\('c'\)\}/);
+  assert.match(reads, /\$\{artistRule\.latestFirst\('c'\)\}/);
+  assert.ok(!/worktree_name IS NULL AND c\.creator_session_id IS NULL/.test(reads), 'no second spelling of the rule');
+});
+
+await test('the backfill brings already-shipped rounds to the same artist, idempotently', () => {
+  const mig = norm(readFileSync(new URL('../migrations/core_267_page_tweak_author_of_record.sql', import.meta.url), 'utf8').replace(/--[^\n]*/g, ''));
+  assert.ok(mig.includes(rule.webClaimPredicate('c')), 'the web-claim predicate');
+  assert.ok(mig.includes(`ORDER BY c.task_id, ${rule.latestFirst('c')}`), 'the latest-first order');
+  assert.match(mig, /pt\.source = 'page-tweak' AND pt\.status = 'shipped'/, 'shipped page tweaks only');
+  assert.match(mig, /t\.shipped_by IS DISTINCT FROM w\.builder_id/, 'a second run matches nothing');
+  assert.ok(!/credit_log/.test(mig), 'money is not touched');
+});
+
+summary();

package/tests/provisioning_planet_physics.mjs

@@ -188,6 +188,20 @@ await t("the spec's three examples fire, each with its why line", () => {
   assert.equal(find({ entity: 'for-profit' }, 'reward_intents:equity').length, 0);
 });
 
+await t('equity is greyed for a single-owner LLC and a research entity, each with its own reason (task 1004475, owner 2026-09-30)', () => {
+  const equity = (entity) => softLimitsFor({ entity }).limits.filter((l) => l.option === 'reward_intents:equity');
+  const llc = equity('single-owner-llc');
+  assert.equal(llc.length, 1); assert.equal(llc[0].effect, 'grey');
+  assert.match(llc[0].reason, /one owner/);
+  const research = equity('research');
+  assert.equal(research.length, 1); assert.equal(research[0].effect, 'grey');
+  assert.match(research[0].reason, /research/i);
+  assert.notEqual(llc[0].reason, research[0].reason, 'each says its own why');
+  // The two companies that can give a builder a stake are still offered it.
+  assert.equal(equity('for-profit').length, 0);
+  assert.equal(equity('corporate-division').length, 0);
+});
+
 await t('a rule never fires on an answer nobody gave — only the platform-wide facts apply to a skipped interview', () => {
   const skipped = softLimitsFor({});
   for (const limit of skipped.limits) {