@bongos/core 1.20.81 → 1.20.83

package/tests/hall_profile_world.mjs

@@ -21,12 +21,13 @@
 //     names; craftMix folds the tail past seven into "other" rather than
 //     minting an eighth hue; weeklyBuckets is a time axis (every week present,
 //     empty or not).
-//   * DRACHMAE COME FROM THE LEDGER (task 1003491). The earned line is the
-//     credits ledger — /me/credits on your own profile, /builders/:id/credits
-//     on another's — `delta` cumulated by `recorded_at`, so it ends at the
-//     balance. Per-task credits_awarded is 0 on a cost-plus instance and is no
-//     longer read at all (the owner's chart had flatlined since July on it).
-//     A viewer the ledger refuses gets the credits_reward estimate, labelled.
+//   * DRACHMAE COME FROM THE LEDGER (task 1003491), and for EVERYONE (task
+//     1004436). The earned line is GET /builders/:id/earnings — the ledger
+//     summed per day and kind, one read for your own profile and anyone's —
+//     cumulated by day, so it ends at the balance. Per-task credits_awarded is
+//     0 on a cost-plus instance and is never read (the owner's chart had
+//     flatlined since July on it). The earnings draw with no shipped task at
+//     all; the tests that prove it live in tests/profile_earnings.mjs.
 //   * NO NUMBER IS PICTURE-ONLY. Every time chart carries a table twin with a
 //     row per plotted day; the readout is written with textContent.
 //   * OWN-ONLY MEANS OWN-ONLY. /analytics/builder/:id is asked for only when
@@ -209,13 +210,13 @@ test('cumulativeByDay folds a day\'s ships into one point and accumulates, skipp
   ], 'newest-first ledger rows still accumulate oldest-first, by their own timestamp');
 });
 
-test('estimateOf is the credits_reward figure and nothing else — the per-task award column is not read anywhere', () => {
+test('the per-task award column is not read anywhere — nor the estimate that stood in for the ledger', () => {
   const C = bootCharts();
-  assert.equal(C.estimateOf({ credits_awarded: 58, credits_reward: 60 }), 60, 'the estimate ignores what was awarded');
-  assert.equal(C.estimateOf({ credits_awarded: 0, credits_reward: 45 }), 45, 'a cost-plus 0 award does not zero the estimate');
-  assert.equal(C.estimateOf({}), 0);
-  assert.equal(C.estimateOf(null), 0);
   assert.equal(C.creditsOf, undefined, 'the old ledger-or-estimate picker is gone');
+  // task 1004436: every signed-in viewer reads the earnings route, so the
+  // credits_reward estimate a refused ledger fell back to has nothing to cover.
+  assert.equal(C.estimateOf, undefined, 'the estimate fallback is gone too');
+  assert.ok(!chartsJs.includes('credits_reward'), 'profile-charts.js never sums an estimate');
   // The whole reason for task 1003491: on a cost-plus instance every task's
   // credits_awarded is 0, so a drachmae series summed from it flatlines the day
   // per-task payout stops. The column must not be read by the charts at all.
@@ -269,10 +270,9 @@ test('clipToWindow (the lookback) enters the window at the running height, not a
 
 // ---- the charts: what render asks for and draws ---------------------------------
 
-// `ledger` is what the credits routes answer: an array of rows (paged by the
-// route's 200 in the real shape, { rows, page: { total } }), or 'denied' for the
-// 403 a viewer without builder.roster.read gets on someone else's ledger.
-function bootRender({ rows, status = 200, analytics = null, ledger = [] }) {
+// `earnings` is what GET /builders/:id/earnings answers: its `days` rows
+// ({ day, kind, credits }), or 'failed' for a 500.
+function bootRender({ rows, status = 200, analytics = null, earnings = [] }) {
   const requests = [];
   const mount = { innerHTML: '', querySelector: () => null };
   const controls = { innerHTML: '', addEventListener() {}, querySelectorAll: () => [] };
@@ -285,10 +285,10 @@ function bootRender({ rows, status = 200, analytics = null, ledger = [] }) {
         const offset = Number(new URL(`http://x${url}`).searchParams.get('offset')) || 0;
         return { status: 200, ok: true, data: { total: rows.length, rows: rows.slice(offset, offset + 100) } };
       }
-      if (url.includes('/credits')) {
-        if (ledger === 'denied') return { status: 403, ok: false, data: null };
-        const offset = Number(new URL(`http://x${url}`).searchParams.get('offset')) || 0;
-        return { status: 200, ok: true, data: { rows: ledger.slice(offset, offset + 200), page: { limit: 200, offset, total: ledger.length } } };
+      if (url.includes('/earnings')) {
+        if (status !== 200) return { status, ok: false, data: null };
+        if (earnings === 'failed') return { status: 500, ok: false, data: null };
+        return { status: 200, ok: true, data: { days: earnings } };
       }
       if (url.includes('/analytics/')) return analytics ? { status: 200, ok: true, data: analytics } : { status: 403, ok: false, data: null };
       return { status: 404, ok: false, data: null };
@@ -324,13 +324,13 @@ function bootRender({ rows, status = 200, analytics = null, ledger = [] }) {
 }
 
 const ship = (d, extra = {}) => ({ shipped_at: `${d}T10:00:00Z`, discipline: 'engineer', credits_awarded: 10, credits_reward: 12, ...extra });
-// a credits-ledger row: what the instance actually paid, when
-const pay = (d, delta, extra = {}) => ({ delta, reason: 'session.token_reward', recorded_at: `${d}T22:00:00Z`, ...extra });
+// an earnings row: what the ledger paid on one day, for one kind of credit
+const pay = (d, credits, kind = 'session') => ({ day: d, kind, credits });
 
 test('render draws three public figures with a table twin per time chart, and no own-only one for another builder', async () => {
   const b = bootRender({
     rows: [ship('2026-08-01'), ship('2026-08-01'), ship('2026-08-20', { discipline: 'ui' })],
-    ledger: [pay('2026-08-01', 20), pay('2026-08-20', 30)],
+    earnings: [pay('2026-08-01', 20), pay('2026-08-20', 30)],
   });
   await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
   const out = b.mount.innerHTML;
@@ -349,8 +349,8 @@ test('render asks for the pace chart on the viewer\'s own profile only', async (
   const own = bootRender({ rows: [ship('2026-08-01')], analytics });
   await own.C.render({ api: own.api, API: '/api/bongos', builderId: 95, selfId: '95', signedIn: true, now: NOW });
   assert.ok(own.requests.some((u) => u.includes('/analytics/builder/95')), 'own profile: the analytics read');
-  assert.ok(own.requests.some((u) => u.includes('/me/credits?')), 'own profile: your own ledger');
-  assert.ok(!own.requests.some((u) => u.includes('/builders/95/credits')), 'never through the roster route for yourself');
+  assert.ok(own.requests.some((u) => u.includes('/builders/95/earnings')), 'own profile: the same earnings read as anyone\'s');
+  assert.ok(!own.requests.some((u) => u.includes('/credits')), 'never the itemised ledger');
   assert.ok(own.mount.innerHTML.includes('id="chart-rate"'), 'and the pace chart draws');
   assert.ok(own.mount.innerHTML.includes('only you see this one'), 'saying plainly that it is private');
 });
@@ -365,10 +365,10 @@ test('signed out, the section says why and asks the server for nothing', async (
   assert.match(gone.mount.innerHTML, /visible to signed-in builders/, 'a 401 mid-way reads the same');
 });
 
-test('an empty record is one honest line, not three empty cards', async () => {
+test('an empty record AND no earnings is one honest line, not three empty cards', async () => {
   const b = bootRender({ rows: [] });
   await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 95, signedIn: true, now: NOW });
-  assert.match(b.mount.innerHTML, /No works shipped yet/);
+  assert.match(b.mount.innerHTML, /Nothing earned or shipped yet/);
   assert.ok(!b.mount.innerHTML.includes('<figure'), 'no figure drew');
   assert.ok(!b.requests.some((u) => u.includes('/analytics/')), 'and nothing else was asked for');
 });
@@ -404,47 +404,41 @@ test('a 30-day window drops the older ships from the craft mix and clips the axi
   assert.equal(C.craftMix(within).length, 1, 'only the recent craft survives a 30-day window');
 });
 
-test('the drachmae line is the credits ledger: /me/credits on your own profile, cumulated by recorded_at, ending at the balance', async () => {
+test('the drachmae line is the earnings by day, cumulated, ending at the balance', async () => {
   const rows = [ship('2026-08-01'), ship('2026-08-20')]; // per-task awards would sum to 20
-  const ledger = [pay('2026-09-01', 12), pay('2026-08-20', 39), pay('2026-08-20', 19), pay('2026-07-05', 30)]; // balance 100
-  const b = bootRender({ rows, ledger });
+  // two kinds on one day are two rows; they fold into one point
+  const earnings = [pay('2026-07-05', 30), pay('2026-08-20', 39), pay('2026-08-20', 19, 'task'), pay('2026-09-01', 12)]; // balance 100
+  const b = bootRender({ rows, earnings });
   await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 95, signedIn: true, now: NOW });
-  assert.ok(b.requests.some((u) => u.includes('/me/credits?limit=200&offset=0')), 'own profile: /me/credits, paged');
-  assert.ok(!b.requests.some((u) => u.includes('/builders/95/credits')), 'not the roster route');
+  assert.ok(b.requests.some((u) => u.endsWith('/api/bongos/builders/95/earnings')), 'one earnings read, unpaged');
   const out = b.mount.innerHTML;
   const fig = out.slice(out.indexOf('id="chart-drachmae"'), out.indexOf('id="chart-mix"'));
   assert.ok(fig.includes('>100 drachmae</text>'), 'the endpoint is the ledger balance, not the 20 of per-task awards');
   assert.ok(fig.includes('<td>2026-07-05</td><td class="ledger__num">30 drachmae</td>'), 'a paid day with no ship is still a point');
-  assert.ok(fig.includes('<td>2026-08-20</td><td class="ledger__num">88 drachmae</td>'), 'two payments on one day fold into one point');
-  assert.match(fig, /100 paid, from the credits ledger/);
+  assert.ok(fig.includes('<td>2026-08-20</td><td class="ledger__num">88 drachmae</td>'), 'two kinds on one day fold into one point');
+  assert.match(fig, /100 drachmae in all/);
   assert.doesNotMatch(fig, /estimated/);
 });
 
-test('another builder\'s ledger is read from /builders/:id/credits, paged by 200 to total', async () => {
-  const ledger = Array.from({ length: 450 }, (_, i) => pay(`2026-08-${String(1 + (i % 28)).padStart(2, '0')}`, 1));
-  const b = bootRender({ rows: [ship('2026-08-01')], ledger });
+test('another builder\'s earnings come from the same route, never the itemised ledger', async () => {
+  const b = bootRender({ rows: [ship('2026-08-01')], earnings: [pay('2026-08-01', 450)] });
   await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
-  const pages = b.requests.filter((u) => u.includes('/builders/95/credits'));
-  assert.equal(pages.length, 3, 'three pages of 200 for 450 rows');
-  assert.ok(!b.requests.some((u) => u.includes('/me/credits')), 'never your own ledger for someone else\'s chart');
-  assert.ok(b.mount.innerHTML.includes('>450 drachmae</text>'), 'and every row counted once');
+  assert.ok(b.requests.some((u) => u.includes('/builders/95/earnings')), 'the earnings read');
+  assert.ok(!b.requests.some((u) => u.includes('/credits')), 'no ledger read, so no viewer is refused and handed an estimate');
+  assert.ok(b.mount.innerHTML.includes('>450 drachmae</text>'));
 });
 
-test('a viewer the ledger refuses gets the credits_reward estimate, cumulated and labelled estimated', async () => {
-  // the cost-plus shape: every award 0, the estimate is all there is to show
-  const rows = [ship('2026-08-01', { credits_awarded: 0, credits_reward: 45 }), ship('2026-08-20', { credits_awarded: 0, credits_reward: 55 })];
-  const b = bootRender({ rows, ledger: 'denied' });
+test('an earnings read that fails says so in its figure; the works charts still draw', async () => {
+  const b = bootRender({ rows: [ship('2026-08-01')], earnings: 'failed' });
   await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
   const out = b.mount.innerHTML;
-  const fig = out.slice(out.indexOf('id="chart-drachmae"'), out.indexOf('id="chart-mix"'));
-  assert.ok(fig.includes('>100 drachmae</text>'), 'the estimate climbs where the 0 awards would have flatlined');
-  assert.match(fig, /estimated from shipped work, not the ledger/);
-  assert.ok(!out.includes('id="chart-rate"'), 'the pace chart stays own-only');
-  assert.ok(!out.includes('Could not load'), 'a 403 on the ledger is a fallback, not a failure');
+  assert.match(out, /Could not load the earnings/);
+  assert.ok(out.includes('id="chart-works"') && out.includes('id="chart-mix"'), 'the record is not taken down with it');
+  assert.doesNotMatch(out, />0 drachmae</, 'never a zero it did not read');
 });
 
-test('a readable ledger with nothing in it draws one honest line, not a crash', async () => {
-  const b = bootRender({ rows: [ship('2026-08-01')], ledger: [] });
+test('earnings with nothing in them, beside a shipped record, draw one honest line, not a crash', async () => {
+  const b = bootRender({ rows: [ship('2026-08-01')], earnings: [] });
   await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 95, signedIn: true, now: NOW });
   const out = b.mount.innerHTML;
   const fig = out.slice(out.indexOf('id="chart-drachmae"'), out.indexOf('id="chart-mix"'));
@@ -452,14 +446,19 @@ test('a readable ledger with nothing in it draws one honest line, not a crash',
   assert.ok(out.includes('id="chart-works"') && out.includes('id="chart-mix"'), 'the other charts are untouched');
 });
 
-test('the harness carries a credits-ledger fixture the chart can climb on, self-paged, serving both routes', () => {
-  const fx = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'me__credits.json'), 'utf8'));
-  assert.ok(Array.isArray(fx.rows) && fx.rows.length > 1, 'rows to draw');
-  assert.equal(fx.page.total, fx.rows.length, 'total pinned to the rows here, or the pager would loop on the same page');
-  assert.ok(fx.rows.every((r) => Number.isFinite(r.delta) && Number.isFinite(Date.parse(r.recorded_at))), 'every row is a delta at a time');
-  assert.ok(new Set(fx.rows.map((r) => r.recorded_at.slice(0, 10))).size > 1, 'across more than one day, so the line is not flat');
+test('the harness carries earnings fixtures the chart can climb on, each summing to its own total', () => {
   const server = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'server.js'), 'utf8');
-  assert.ok(server.includes("[/^builders\\/\\d+\\/credits$/, 'me__credits']"), 'the roster route falls back to the same ledger');
+  assert.ok(server.includes("[/^builders\\/\\d+\\/earnings$/, 'builders__earnings']"), 'any id falls back to the generic earnings');
+  for (const name of ['builders__earnings', 'builders__2001__earnings', 'builders__2002__earnings']) {
+    const fx = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', `${name}.json`), 'utf8'));
+    assert.ok(Array.isArray(fx.days) && new Set(fx.days.map((d) => d.day)).size > 1, `${name}: across more than one day, so the line is not flat`);
+    assert.ok(fx.days.every((d) => /^\d{4}-\d{2}-\d{2}$/.test(d.day) && Number.isFinite(d.credits)), `${name}: every row is credits on a day`);
+    const sum = fx.days.reduce((s, d) => s + d.credits, 0);
+    assert.equal(sum, fx.total, `${name}: the days add up to the total`);
+    for (const [kind, n] of Object.entries(fx.totals)) {
+      assert.equal(fx.days.filter((d) => d.kind === kind).reduce((s, d) => s + d.credits, 0), n, `${name}: ${kind} adds up`);
+    }
+  }
 });
 
 test('the readout is written with textContent — the hover layer never builds markup from data', () => {

package/tests/profile_earnings.mjs

@@ -0,0 +1,237 @@
+// tests/profile_earnings.mjs — everyone gets an earnings chart, labelled by kind
+// of credit (task 1004436 / WA6.RP06, goal 1000095, criterion
+// wa6-roles-read-true-in-public).
+//
+// The done-when: "an artist and an ideator fixture with credits and zero shipped
+// tasks both get a labelled earnings chart". Run for real, end to end:
+//
+//   1. THE KINDS. Which kind each ledger reason is, as the read's own SQL says it,
+//      and the one kind the reason cannot tell apart (a descent hop shares stream
+//      1's key) held against the WRITER's own description text.
+//   2. THE FOLD. Every kind named, zero days dropped, the parts summing to the
+//      whole.
+//   3. THE ROUTE. Signed in only, a bad id refused, an unknown builder a 404, and
+//      the read scoped to that one builder.
+//   4. THE PAGE. The REAL profile-charts.js on the REAL kit, fed the harness's
+//      artist and ideator fixtures (credits, no shipped task): a figure, its
+//      lede, and "where it came from" in the mock's words.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const { test, summary } = makeRunner();
+
+const earnings = require('../modules/economy/earnings.js');
+const credits = require('../modules/economy/credits.js');
+const fixture = (name) => JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures', `${name}.json`), 'utf8'));
+
+// ---- 1. the kinds -------------------------------------------------------------
+
+await test('every kind the SQL can name is a kind the page has words for', () => {
+  const named = [...earnings.EARNINGS_SQL.matchAll(/THEN '([a-z-]+)'/g)].map((m) => m[1]);
+  named.push('other'); // the ELSE
+  assert.deepEqual([...new Set(named)].sort(), [...earnings.KINDS].sort(), 'the SQL and KINDS name the same set');
+  const page = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile-charts.js'), 'utf8');
+  for (const k of earnings.KINDS) assert.ok(page.includes(`${k.includes('-') ? `'${k}'` : k}: '`), `the page has words for ${k}`);
+});
+
+await test('a descent hop is told from a direct payout by the WRITER\'s own words', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/economy/credits.js'), 'utf8');
+  // the descent writer and the direct writer, by their own describe() lines
+  const descent = src.match(/describe: \(p\) => `Task #\$\{taskId\} shipped \$\{depth\} hop[^\n]*/);
+  const direct = src.match(/describe: \(p\) => `Task #\$\{taskId\} shipped under idea[^\n]*/);
+  assert.ok(descent && direct, 'both writers are where this test reads them');
+  assert.ok(descent[0].includes(earnings.DESCENT_MARK.trim()), 'the descent writer says DESCENT_MARK');
+  assert.ok(!direct[0].includes(earnings.DESCENT_MARK.trim()), 'and the direct one does not, or every idea payout would read as descent');
+  // the descent case is checked BEFORE the plain stream-1 case, or it never matches
+  const sql = earnings.EARNINGS_SQL;
+  assert.ok(sql.indexOf("'idea-descent'") < sql.indexOf("'idea-ship'"), 'descent first');
+});
+
+await test('the LIKE patterns are the economy\'s own prefixes, escaped', async () => {
+  let seen = null;
+  await earnings.readEarnings('7', { client: { query: async (sql, params) => { seen = { sql, params }; return { rows: [] }; } } });
+  assert.equal(seen.params[0], '7', 'scoped to the one builder');
+  assert.equal(seen.params[1], credits.ARTIST_PAGE_REASON_PREFIX.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[2], credits.IDEA_STREAM_REASON_PREFIXES.task_ship.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[3], credits.IDEA_STREAM_REASON_PREFIXES.full_pass.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[4], credits.IDEA_STREAM_REASON_PREFIXES.governance_pass.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[5], `%${earnings.DESCENT_MARK}%`);
+  assert.match(seen.sql, /WHERE builder_id = \$1\b/, 'never the whole ledger');
+  assert.doesNotMatch(seen.sql.split('FROM')[0].replace(/COALESCE\(description[^)]*\)/, ''), /description|task_id|session_id/, 'no itemisation leaves the read');
+});
+
+// ---- 2. the fold --------------------------------------------------------------
+
+await test('the fold names every kind, drops zero days, sums to the whole and sorts by day', () => {
+  const out = earnings.foldEarnings([
+    { day: '2026-09-02', kind: 'page', credits: 30 },
+    { day: '2026-09-01', kind: 'idea-ship', credits: 12.4 },
+    { day: '2026-09-01', kind: 'session', credits: 0 },
+    { day: '2026-09-03', kind: 'something-new', credits: 5 },
+  ]);
+  assert.deepEqual(Object.keys(out.totals).sort(), [...earnings.KINDS].sort(), 'every kind, zero where nothing was earned');
+  assert.equal(out.totals.page, 30);
+  assert.equal(out.totals['idea-ship'], 12);
+  assert.equal(out.totals.other, 5, 'a kind the table does not know is still counted');
+  assert.equal(out.total, 47);
+  assert.deepEqual(out.days.map((d) => d.day), ['2026-09-01', '2026-09-02', '2026-09-03'], 'the zero day is gone');
+});
+
+// ---- 3. the route -------------------------------------------------------------
+
+await test('the route: signed in only, a bad id refused, an unknown builder a 404', async () => {
+  const api = require('../src/module-api.js');
+  // The read itself is proven above through its `client` seam, against its own
+  // SQL; here it is swapped before the route loads (the route takes it at
+  // require time), so the test never opens a database pool.
+  const realRead = earnings.readEarnings;
+  const realGet = api.getBuilderById;
+  const realRequire = api.requireBuilder;
+  const asked = [];
+  earnings.readEarnings = async (id) => { asked.push([id]); return earnings.foldEarnings([{ day: '2026-09-01', kind: 'page', credits: 30 }]); };
+  api.getBuilderById = async (id) => (String(id) === '2001' ? { id: 2001 } : null);
+  let signedIn = true;
+  api.requireBuilder = (req, res, next) => (signedIn ? next() : res.status(401).json({ error: 'unauthorized' }));
+  const express = require('express');
+  const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+  const app = express();
+  app.use(attachFail);
+  app.use(require('../modules/economy/routes/earnings.js')());
+  const server = await new Promise((r) => { const s = app.listen(0, '127.0.0.1', () => r(s)); });
+  const get = async (p) => { const r = await fetch(`http://127.0.0.1:${server.address().port}${p}`); return { status: r.status, body: await r.json() }; };
+  try {
+    const ok = await get('/builders/2001/earnings');
+    assert.equal(ok.status, 200);
+    assert.equal(ok.body.total, 30);
+    assert.deepEqual(ok.body.days, [{ day: '2026-09-01', kind: 'page', credits: 30 }]);
+    assert.equal(String(asked.at(-1)[0]), '2001', 'the read is that builder\'s rows');
+    assert.equal((await get('/builders/abc/earnings')).status, 400);
+    assert.equal((await get('/builders/9999/earnings')).status, 404);
+    signedIn = false;
+    assert.equal((await get('/builders/2001/earnings')).status, 401, 'owner decision (a): earnings need a sign-in');
+  } finally {
+    earnings.readEarnings = realRead;
+    api.getBuilderById = realGet;
+    api.requireBuilder = realRequire;
+    server.closeAllConnections();
+    await new Promise((r) => server.close(r));
+    // Let the closed sockets' handles finish closing before the runner's
+    // process.exit, or Windows' libuv aborts on a handle still mid-close.
+    await new Promise((r) => setTimeout(r, 50));
+  }
+});
+
+await test('the economy module mounts the route', () => {
+  const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules/economy/module.json'), 'utf8'));
+  assert.ok(manifest.contributes.routes.includes('earnings'));
+});
+
+// ---- 4. the page --------------------------------------------------------------
+
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const NOW = Date.parse('2026-10-01T12:00:00Z');
+
+function bootCharts(route) {
+  const requests = [];
+  const mount = { innerHTML: '', querySelector: () => null };
+  const controls = { innerHTML: '', addEventListener() {}, querySelectorAll: () => [] };
+  const api = {
+    request: async (method, url) => {
+      requests.push(url);
+      const hit = route(url);
+      return hit ? { status: 200, ok: true, data: hit } : { status: 404, ok: false, data: null };
+    },
+  };
+  const sandbox = {
+    window: {
+      __BRANDING__: { currency: { label: 'credits' } },
+      localStorage: { getItem: () => null, setItem() {} },
+      OTB: {
+        roleAxisLabel: () => 'Role',
+        roleLabel: (d) => d,
+        escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+        $: (sel) => (sel === '#charts-grid' ? mount : sel === '#charts-controls' ? controls : null),
+        fmtNum: (n) => String(n ?? 0),
+        fmtDate: (iso) => String(iso ?? '').slice(0, 10),
+      },
+    },
+    console, Date, Map, Set, Math, Number, String, Array, Object, Infinity, URLSearchParams, Promise,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const f of ['hall-kit.js', 'profile-charts.js']) {
+    vm.runInContext(fs.readFileSync(path.join(HALL, f), 'utf8'), sandbox, { filename: f });
+  }
+  return { C: sandbox.window.OTBProfileCharts, api, requests, mount };
+}
+
+// the harness's own fixtures: an artist and an ideator who never shipped a task
+const PEOPLE = [
+  {
+    who: 'artist', id: 2001, name: 'Builder 7',
+    lede: 'Builder 7 has never shipped a task. Every credit here came from approved pages and ideas.',
+    kinds: [['Pages approved', '370'], ['Ideas that became shipped work', '42']],
+    end: '412 credits',
+  },
+  {
+    who: 'ideator', id: 2002, name: 'Builder 9',
+    lede: 'Builder 9 has never shipped a task. Every credit here came from ideas.',
+    kinds: [['Ideas that became shipped work', '96'], ['Work split from their ideas', '38'], ['Ratified by the board', '30'], ['Full Ideas passed', '22']],
+    end: '186 credits',
+  },
+];
+
+for (const P of PEOPLE) {
+  await test(`the ${P.who} fixture, with credits and no shipped task, gets a labelled earnings chart`, async () => {
+    const activity = fixture(`builders__${P.id}__activity`);
+    const earned = fixture(`builders__${P.id}__earnings`);
+    assert.equal(activity.rows.length, 0, 'the fixture really has no shipped task');
+    const b = bootCharts((url) => (url.includes('/activity') ? activity : url.includes('/earnings') ? earned : null));
+    await b.C.render({ api: b.api, API: '/api/bongos', builderId: P.id, selfId: 1, signedIn: true, name: P.name, now: NOW });
+    const out = b.mount.innerHTML;
+    assert.ok(out.includes('id="chart-drachmae"'), 'the earnings figure drew');
+    assert.ok(out.includes('Earnings over time'));
+    assert.ok(out.includes(P.lede), 'the lede says who never shipped, and where the credits came from');
+    assert.ok(out.includes(`>${P.end}</text>`), 'the line ends at the balance');
+    assert.ok(out.includes('where it came from'));
+    // "where it came from", in order, with its numbers
+    const rows = [...out.matchAll(/<span class="kit-bars__label">([^<]+)<\/span>[\s\S]*?<span class="kit-bars__val">([^<]+)<\/span>/g)].map((m) => [m[1], m[2]]);
+    assert.deepEqual(rows, P.kinds, 'every kind that earned, largest first, in the mock\'s words');
+    assert.ok(out.includes('No works shipped yet'), 'the works charts say "none yet" on their own');
+    assert.ok(!out.includes('id="chart-works"'), 'and draw no empty card');
+    assert.ok(!b.requests.some((u) => u.includes('/credits')), 'the itemised ledger is never read');
+  });
+}
+
+await test('the kinds follow the lookback window; the line still ends at the all-time total', () => {
+  const b = bootCharts(() => null);
+  const days = [{ day: '2026-06-01', kind: 'page', credits: 100 }, { day: '2026-09-25', kind: 'idea-ship', credits: 5 }];
+  assert.deepEqual(JSON.parse(JSON.stringify(b.C.earningsKinds(days))).map((k) => k.kind), ['page', 'idea-ship']);
+  assert.deepEqual(JSON.parse(JSON.stringify(b.C.earningsKinds(days.slice(1)))).map((k) => k.kind), ['idea-ship'], 'a 30-day window drops June');
+});
+
+await test('the lede: your own profile says "you"; someone who ships gets the plain sentence', () => {
+  const { C } = bootCharts(() => null);
+  const kinds = [{ kind: 'idea-ship', credits: 5 }];
+  assert.equal(C.earningsLede({ isOwn: true, shipped: false, kinds }), 'You have never shipped a task. Every credit here came from ideas.');
+  assert.equal(C.earningsLede({ name: 'Mara', isOwn: false, shipped: true, kinds }), 'Every credit Mara has earned, by the kind of work that earned it.');
+  assert.equal(C.earningsLede({ isOwn: true, shipped: true, kinds }), 'Every credit you have earned, by the kind of work that earned it.');
+});
+
+await test('signed out, nothing is asked for and the line says why', async () => {
+  const b = bootCharts(() => ({}));
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 2002, selfId: null, signedIn: false, now: NOW });
+  assert.equal(b.requests.length, 0);
+  assert.match(b.mount.innerHTML, /Earnings and shipped work are visible to signed-in builders/);
+});
+
+summary();

package/tests/projects_hub_app_status.mjs

@@ -117,6 +117,23 @@ test('building and creating say where it is, with the stage marked', () => {
   assert.match(w.html({ app: { ...BUILDING.app, mode: 'adopt' } }), /Linked\. Waiting for your app to answer/);
 });
 
+// Task 1004502: past the time box the card stops saying "building" and sends the owner to
+// Render's deploy history, while the watch keeps asking (the app may still come up).
+test('a quiet build: no "building", the way to Render\'s deploy history, and the watch keeps going', () => {
+  const w = load();
+  const QUIET = { ok: true, app: { ...BUILDING.app, stage: 'quiet', quiet: true,
+    links: { ...LINKS, deploys: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/events' } }, env_vars: [] };
+  const html = w.html(QUIET);
+  assert.doesNotMatch(html, /Render is building your app/);
+  assert.doesNotMatch(html, /appStages/, 'no progress rail claims a stage');
+  assert.match(html, /<p>Your app hasn’t answered for over 20 minutes\. Render may have stopped the deploy — its deploy history says why\.<\/p>/);
+  assert.match(html, /<a href="https:\/\/dashboard\.render\.com\/web\/srv-aaaaaaaa1111\/events" target="_blank" rel="noopener noreferrer">See its deploys on Render<\/a>/);
+  assert.match(html, /If it starts answering, this changes to Live by itself\./);
+  assert.equal(w.appTerminal(QUIET), false, 'the watch keeps asking');
+  const adopt = w.html({ ...QUIET, app: { ...QUIET.app, mode: 'adopt' } });
+  assert.match(adopt, /Your app hasn’t answered for over 20 minutes/);
+});
+
 test('a failure: the sentence, a Retry, and no promise of a retry by itself', () => {
   const w = load();
   const v = w.view(FAILED);

package/tests/provisioning_app_status.mjs

@@ -48,7 +48,8 @@ await ta('each runner state maps to the stage the owner sees', () => {
 await ta('a live app carries its address and the two Render links', () => {
   const s = appStatus({ ...HOST, state: 'live' });
   assert.equal(s.url, 'https://demo.onrender.com');
-  assert.deepEqual(s.links, { service: 'https://dashboard.render.com/web/srv-aaaaaaaa1111', env: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/env' });
+  assert.deepEqual(s.links, { service: 'https://dashboard.render.com/web/srv-aaaaaaaa1111', env: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/env',
+    deploys: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/events' });
   assert.equal(s.error, null);
   assert.equal(s.retry, null);
 });
@@ -75,6 +76,29 @@ await ta('a run still holding the lent key reads as waiting, not as something to
   assert.equal(s.retry, null);
 });
 
+// Task 1004502: Render can give up on a deploy (project 43 timed out in 15 minutes) and the
+// address check alone can never learn it, so a build that has not answered in QUIET_AFTER_MS
+// stops claiming to be building and sends the owner to Render's own deploy history.
+await ta('a build with no answer past the time box reads "quiet", not "building" (task 1004502)', () => {
+  const { QUIET_AFTER_MS } = require('../modules/provisioning/app-status.js');
+  assert.equal(QUIET_AFTER_MS, 20 * 60_000);
+  const t0 = Date.parse('2026-10-01T10:00:00Z');
+  const at = (state, ms) => appStatus({ ...HOST, state, updatedAt: new Date(t0).toISOString() }, { now: t0 + ms });
+  assert.equal(at('deploying', QUIET_AFTER_MS - 1000).quiet, false, 'still inside the time box');
+  assert.equal(at('deploying', QUIET_AFTER_MS - 1000).stage, 'building');
+  const q = at('deploying', QUIET_AFTER_MS + 1000);
+  assert.equal(q.quiet, true);
+  assert.equal(q.stage, 'quiet', 'it no longer reads as building');
+  assert.equal(q.links.deploys, 'https://dashboard.render.com/web/srv-aaaaaaaa1111/events');
+  assert.equal(q.error, null, 'not a failure: the platform cannot see Render\'s verdict');
+  assert.equal(q.retry, null);
+  assert.equal(at('linked', QUIET_AFTER_MS + 1000).stage, 'quiet', 'an adopted app waits the same way');
+  assert.equal(at('live', QUIET_AFTER_MS * 10).stage, 'live', 'a live app is never quiet');
+  assert.equal(at('creating', QUIET_AFTER_MS * 10).quiet, false, 'only a build is time-boxed');
+  assert.equal(appStatus({ ...HOST, state: 'deploying' }, { now: t0 }).quiet, false, 'no start time → no claim');
+  assert.equal(appStatus({ ...HOST, state: 'deploying', updatedAt: 'nonsense' }, { now: t0 }).quiet, false);
+});
+
 console.log('\nGET /provisioning/instances/:id/render:');
 const provisioning = require('../modules/provisioning/provisioning.js');
 const envManifest = require('../modules/provisioning/env-manifest.js');