@bongos/core 1.21.169 → 1.21.171

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

@@ -60,14 +60,14 @@ function well(over = {}) {
       { id: '71', criterion_id: 'c2', criterion_md: 'The second ring is open', satisfied: false, pending_review: false, task_ids: ['501', '502'] },
     ],
     tasks: [
-      { id: '500', title: 'The task', status: 'shipped', credits_reward: 60, created_on: '2026-07-01', idea_id: '10' },
+      { id: '500', title: 'The task', status: 'shipped', credits_reward: 60, credits_awarded: 60, created_on: '2026-07-01', idea_id: '10' },
       { id: '501', title: 'A held task', status: 'active', credits_reward: 40, created_on: '2026-08-01', idea_id: null },
       { id: '502', title: 'A claimable task', status: 'ready', credits_reward: 30, created_on: '2026-08-02', idea_id: null },
     ],
     ...over,
   };
 }
-const tasksOf = (prefix, n, status, created = '2026-05-01') => Array.from({ length: n }, (_, i) => ({ id: `${prefix}${i}`, title: `task ${prefix}${i}`, status, credits_reward: 20, created_on: created, idea_id: null }));
+const tasksOf = (prefix, n, status, created = '2026-05-01') => Array.from({ length: n }, (_, i) => ({ id: `${prefix}${i}`, title: `task ${prefix}${i}`, status, credits_reward: 20, credits_awarded: status === 'shipped' ? 20 : 0, created_on: created, idea_id: null }));
 // A quiet well: nothing held, nothing landed this week.
 const quiet = (over = {}) => well({ goal_id: '9', title: 'A quiet well — nothing moves', task_total: 4, task_done: 4, criteria: [], tasks: tasksOf('9-', 4, 'shipped'), ...over });
 const settled = (over = {}) => well({ goal_id: '8', title: 'A settled system — it finished', status: 'achieved', task_total: 3, task_done: 3, tasks: tasksOf('8-', 3, 'shipped'), created_at: '2026-03-01T00:00:00.000Z', ...over });
@@ -142,7 +142,7 @@ await test('a goal is a well sized by its credits; settled and collapsed goals k
   assert.equal(o.mass, 60);
   assert.ok(Math.abs(a.r - o.r * 0.8) < 1e-9, 'a settled system is 0.8× the well it would have been');
   assert.ok(Math.abs(c.r - o.r * 0.5) < 1e-9, 'a collapsed goal is half');
-  const big = await boot({ sky: sky([well(same({ goal_id: '1' })), well({ ...same({ goal_id: '4' }), tasks: tasksOf('4-', 3, 'shipped').map((t) => ({ ...t, credits_reward: 400 })) })]) });
+  const big = await boot({ sky: sky([well(same({ goal_id: '1' })), well({ ...same({ goal_id: '4' }), tasks: tasksOf('4-', 3, 'shipped').map((t) => ({ ...t, credits_reward: 400, credits_awarded: 400 })) })]) });
   assert.ok(goal(big, '4').r > goal(big, '1').r, 'more credits, a bigger well');
 });
 
@@ -227,7 +227,7 @@ await test('EXPLORE IS ON BY DEFAULT: the sky asks where you begin, and the ledg
   assert.equal(p.el('start').hidden, false, '"where do you begin" is up');
   const opts = p.el('startOpts').querySelectorAll('button');
   assert.equal(opts[0].textContent, 'where my thoughts are');
-  assert.deepEqual(opts.slice(1, -1).map((b) => b.dataset.start), ['7', '9'], 'one door per open well, biggest first');
+  assert.deepEqual(opts.slice(1, -1).map((b) => b.dataset.start), ['9', '7'], 'one door per open well, biggest first (task 1004781: 7 weighs only the 60 it paid now)');
   assert.equal(opts.at(-1).textContent, 'show me everything');
   assert.equal(SKY.seen(goal(p, '7')), false, 'nothing is reached yet');
   p.key('l');
@@ -283,7 +283,7 @@ await test('THE LEDGER IS THE ACCESSIBLE PATH: every goal is a row, both directi
     assert.ok(rows.includes(SKY.esc(g.title)), `${g.title} is named whole`);
   }
   const rowOf = (id) => (new RegExp(`data-id="${id}"[\\s\\S]*?</button>`).exec(rows) || [''])[0];
-  assert.match(rowOf('7'), /alive · 1\/3 tasks · 130 cr · 1\/2 rings · waits on 1/, 'the waiting goal (alive: a task is held) counts what it waits on');
+  assert.match(rowOf('7'), /alive · 1\/3 tasks · 60 cr · 1\/2 rings · waits on 1/, 'the waiting goal (alive: a task is held) counts what it waits on');
   assert.match(rowOf('9'), /waited on by 1/, 'the goal waited on counts it the other way');
   assert.match(rowOf('8'), /settled/); assert.match(rowOf('6'), /collapsed/);
   const filters = p.el('filters').querySelectorAll('button').map((b) => [b.dataset.f, b.textContent.replace(/\s*\d+$/, '').trim()]);

package/tests/hall_approval_queue.mjs

@@ -311,6 +311,41 @@ await test('empty, closed with Escape, and focus goes back where it was', async
   assert.deepEqual(b.counts, [0]);
 });
 
+// task 1004765: a round SUBMITTED but never applied sat unseen for weeks. The
+// server lists it apart (not_applied), the panel shows it below the reviewable
+// page, marked, with how long it has waited, and with no verb; the door counts
+// only what can be reviewed.
+await test('submitted but not applied: listed apart, marked, how long, no verbs, not in the door count', async () => {
+  const NOW = Date.parse('2026-10-20T12:00:00Z');
+  const submitted = {
+    id: 60, status: 'ready', holder_id: null, artist_id: ME, artist_login: 'me', updated_at: '2026-09-29T08:00:00Z',
+    source_ref: pages.roundSourceRef('landing:projects', 2),
+    description: ['Page tweak round 2.', pages.composeBatchBlock({ page_id: 'landing:projects', reading_hash: 'h', submitted_at: '2026-09-29T08:00:00Z', lines: [{ key: 'L0002', section: 'list', before: 'Every project', after: 'All of them', placement: 'placed', file: 'x.html', line: 1, string_id: 'a' }] })].join('\n\n'),
+  };
+  const tasks = [...TASKS.filter((t) => t.id !== 42), submitted];
+  const data = pageStatus.composeApprovals({ inventory: INVENTORY, tasks, builderId: ME, crafts: ['artist'], now: NOW });
+  assert.equal(data.count, 1, 'the door counts reviewable rounds only');
+  assert.deepEqual(data.queue.map((q) => q.task_id), ['41']);
+  assert.deepEqual(data.not_applied.map((r) => [r.page_id, r.task_id, r.state_word, r.waited_days, r.line_count]),
+    [['landing:projects', '60', 'Submitted, waiting to be applied', 21, 1]]);
+
+  const b = bootPanel({ answers: { [APPROVALS]: { ok: true, ...data }, [vis(41)]: slotsFor(41) } });
+  await b.panel.open(); await settle(); await settle();
+  assert.equal(text(b.q('.aq-pending__h')), 'Submitted, not applied yet (1)');
+  const row = b.q('.aq-pending__row');
+  assert.match(text(row), /Projects/);
+  assert.match(text(row), /not applied yet/);
+  assert.match(text(row), /Submitted, waiting to be applied · waiting 21 days\. The words are waiting to be applied/);
+  assert.equal(row.querySelectorAll('button').length, 0, 'no approve or send-back on a page nobody applied');
+  assert.deepEqual(b.counts, [1]);
+
+  const empty = bootPanel({ answers: { [APPROVALS]: { ok: true, ...pageStatus.composeApprovals({ inventory: INVENTORY, tasks: [submitted], builderId: ME, crafts: ['artist'], now: NOW }) } } });
+  await empty.panel.open(); await settle();
+  assert.equal(text(empty.q('.aq-title')), 'Nothing waiting', 'nothing to review');
+  assert.ok(empty.q('.aq-pending__row'), 'but the submitted page is still shown');
+  assert.deepEqual(empty.counts, [0]);
+});
+
 // ── the writes: only the host's, and the host's are the studio's allowlist ──
 
 await test('the panel writes only through the writes it is handed; the studio hands it its own WRITE_ROUTES', () => {

package/tests/hall_sky.mjs

@@ -92,7 +92,7 @@ function well(over = {}) {
       { id: '71', criterion_id: 'c2', criterion_md: 'The second ring is open', satisfied: false, pending_review: false, task_ids: ['501', '502'] },
     ],
     tasks: [
-      { id: '500', title: 'The task', status: 'shipped', credits_reward: 60, created_on: '2026-07-01', idea_id: '10' },
+      { id: '500', title: 'The task', status: 'shipped', credits_reward: 60, credits_awarded: 6, created_on: '2026-07-01', idea_id: '10' },
       { id: '501', title: 'A held task', status: 'active', credits_reward: 40, created_on: '2026-08-01', idea_id: null },
       { id: '502', title: 'A claimable task', status: 'ready', credits_reward: 30, created_on: '2026-08-02', idea_id: null },
     ],
@@ -211,7 +211,18 @@ await test('the rings are the criteria, closing as each is satisfied and thick w
   const g = p.S().goalById.get('7');
   assert.equal(g.crit.length, 2);
   same(g.crit.map((c) => c.satisfied), [true, false]);
-  same(g.crit.map((c) => c.credits), [60, 70], 'a ring\'s credits are the credits of the tasks on it');
+  // task 1004781 — a ring weighs what its tasks were PAID: the shipped task paid 6 (its 60 was a guess), and
+  // the held and claimable tasks have paid nothing yet, so their estimates stay off the ring.
+  same(g.crit.map((c) => c.credits), [6, 0], 'a ring\'s credits are what the tasks on it were paid');
+  assert.equal(g.tasks.find((t) => t.id === '500').estimate, null, 'a settled task carries no estimate');
+  assert.equal(g.tasks.find((t) => t.id === '501').estimate, 40, 'live work keeps its estimate, apart from the total');
+  const SKY = p.SKY();
+  SKY.pick({ kind: 'task', ref: g.tasks.find((t) => t.id === '501') }, false);
+  assert.match(p.panel(), /40 <span class="lbl">Est\.<\/span>/, 'the panel labels a live task\'s figure as an estimate');
+  assert.doesNotMatch(p.panel(), /credits paid/);
+  SKY.pick({ kind: 'task', ref: g.tasks.find((t) => t.id === '500') }, false);
+  assert.match(p.panel(), /credits paid[\s\S]*?6/, 'and a settled task\'s as what it was paid');
+  assert.doesNotMatch(p.panel(), /Est\./);
   assert.equal(g.tasks.find((t) => t.id === '500').ci, 0, 'a task knows which ring it gates');
   assert.equal(g.tasks.find((t) => t.id === '500').sourceRef, '10', 'and which thought it was born of');
 });
@@ -230,8 +241,9 @@ await test('abandoned work is listed at zero and adds nothing to a well or its r
   const g = p.S().goalById.get('7');
   assert.equal(g.tasks.find((t) => t.id === '503').credits, 0, 'still listed, at zero');
   assert.equal(g.tasks.find((t) => t.id === '504').credits, 0, 'a merged-away task is listed at zero too');
-  assert.equal(g.credits, 130, 'the well\'s mass is the live work only (60 + 40 + 30)');
-  same(g.crit.map((c) => c.credits), [60, 70], 'and the ring it sat on is not thickened by it');
+  assert.equal(g.credits, 6, 'the well\'s mass is what was paid only');
+  same(g.crit.map((c) => c.credits), [6, 0], 'and the ring it sat on is not thickened by it');
+  assert.equal(g.tasks.find((t) => t.id === '503').estimate, null, 'abandoned work carries no estimate either');
 });
 
 await test('a private goal keeps its structure and none of its prose', async () => {

package/tests/module_assess_installs.mjs

@@ -20,7 +20,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const { MIN_HOLDERS, assessInstall, assessReliability, recordInstallSignals } = require('../scripts/gds/module-assess-installs.js');
+const { MIN_HOLDERS, PRIOR_TESTERS, assessInstall, assessReliability, assessTesterFeedback, recordInstallSignals } = require('../scripts/gds/module-assess-installs.js');
 const reports = require('../src/bongos/module-usage-reports.js');
 const { ERROR_CODE_RE } = require('../src/bongos/module-usage-reports.js');
 const { cmdInstall } = require('../scripts/gds/module.js');
@@ -146,11 +146,13 @@ test('the switch: off writes an opt-out row, on deletes it', async () => {
 
 // ---- the re-score ----
 
-function scoringDb({ latest, days, current = [] }) {
+function scoringDb({ latest, days, current = [], testerInstalls = [], testerDays = [] }) {
   return fakeDb([
-    [/FROM module_install_reports r/, () => ({ rows: latest })],
-    [/FROM module_runtime_error_counts r/, () => ({ rows: days })],
-    [/part IN \('install', 'reliability'\)/, () => ({ rows: current })],
+    [/FROM module_install_reports r\s/, () => ({ rows: latest })],
+    [/FROM module_runtime_error_counts r\s/, () => ({ rows: days })],
+    [/FROM module_install_reports ir/, () => ({ rows: testerInstalls })],
+    [/FROM module_runtime_error_counts ec/, () => ({ rows: testerDays })],
+    [/part IN \('install', 'reliability', 'tester_feedback'\)/, () => ({ rows: current })],
     [/INSERT INTO module_assessment_signals/, () => ({ rows: [] })],
     [/SELECT DISTINCT ON \(part\) id, part, outcome, score, sample_size/, () => ({ rows: [] })],
     [/FROM module_assessment_scores/, () => ({ rows: [] })],
@@ -173,7 +175,10 @@ test('re-score: writes a signal row only for a part whose result moved, then re-
   const latest = [{ ok: true }, { ok: true }, { ok: false, error_code: 'place_failed' }];
   const db = scoringDb({
     latest, days: [],
-    current: [{ part: 'reliability', outcome: 'no_data', score: null, sample_size: 0 }],
+    current: [
+      { part: 'reliability', outcome: 'no_data', score: null, sample_size: 0 },
+      { part: 'tester_feedback', outcome: 'no_data', score: null, sample_size: 0 },
+    ],
   });
   const res = await recordInstallSignals(5, { db });
   assert.deepEqual(res.written, ['install'], 'reliability is unchanged, so no new row');
@@ -184,12 +189,73 @@ test('re-score: writes a signal row only for a part whose result moved, then re-
   const again = scoringDb({ latest, days: [], current: [
     { part: 'install', outcome: 'scored', score: 67, sample_size: 3 },
     { part: 'reliability', outcome: 'no_data', score: null, sample_size: 0 },
+    { part: 'tester_feedback', outcome: 'no_data', score: null, sample_size: 0 },
   ] });
   const res2 = await recordInstallSignals(5, { db: again });
   assert.deepEqual(res2.written, []);
   assert.ok(!again.calls.some((c) => /INSERT/.test(c.sql)), 'nothing moved, nothing written');
 });
 
+// ---- tester feedback (task 1003806, ADR 0344 D5) ----
+
+const testers = (n, { failed = 0, erroring = 0 } = {}) => {
+  const installs = Array.from({ length: n }, (_, i) => ({ holder_kind: 'instance', holder_ref: `p${i}`, ok: i >= failed, error_code: i < failed ? 'place_failed' : null }));
+  const days = Array.from({ length: erroring }, (_, i) => ({ holder_kind: 'instance', holder_ref: `p${n - 1 - i}`, error_count: 2 }));
+  return { installs, days };
+};
+
+test('Tester feedback: no tester reports is no_data, and fewer than MIN_HOLDERS is pending', () => {
+  assert.equal(assessTesterFeedback({}).outcome, 'no_data');
+  const s = assessTesterFeedback(testers(MIN_HOLDERS - 1));
+  assert.equal(s.outcome, 'pending');
+  assert.equal(s.score, null);
+});
+
+test('Tester feedback: a tester it went well for installed cleanly AND hit no runtime errors', () => {
+  const s = assessTesterFeedback(testers(20, { failed: 2, erroring: 3 }));
+  assert.equal(s.detail.went_well, 15);
+  assert.equal(s.detail.install_failed, 2);
+  assert.equal(s.detail.with_errors, 3);
+  assert.equal(s.detail.errors, 6);
+  assert.equal(s.score, Math.round((100 * (15 + PRIOR_TESTERS / 2)) / (20 + PRIOR_TESTERS)));
+});
+
+test('Tester feedback: a tester who only sent error counts still counts once', () => {
+  const s = assessTesterFeedback({ installs: [], days: [
+    { holder_kind: 'instance', holder_ref: 'a', error_count: 0 },
+    { holder_kind: 'instance', holder_ref: 'a', error_count: 0 },
+    { holder_kind: 'instance', holder_ref: 'b', error_count: 0 },
+    { holder_kind: 'builder', holder_ref: 'a', error_count: 1 },
+  ] });
+  assert.equal(s.sample_size, 3);
+  assert.equal(s.detail.went_well, 2);
+});
+
+test('Tester feedback: sample size weighs — a few friendly testers cannot outrank many real ones', () => {
+  const few = assessTesterFeedback(testers(3)).score;
+  const many = assessTesterFeedback(testers(200, { failed: 10 })).score;
+  assert.ok(many > few, `200 testers at 95% (${many}) must beat 3 at 100% (${few})`);
+  assert.ok(assessTesterFeedback(testers(200)).score >= 95, 'a large clean sample still scores high');
+});
+
+test('re-score: tester reports are read only inside the tester window, author excluded', async () => {
+  const t4 = testers(4);
+  const db = scoringDb({ latest: [], days: [], testerInstalls: t4.installs, testerDays: t4.days });
+  const res = await recordInstallSignals(5, { db });
+  assert.ok(res.written.includes('tester_feedback'));
+  assert.equal(res.signals.tester_feedback.score, Math.round((100 * (4 + PRIOR_TESTERS / 2)) / (4 + PRIOR_TESTERS)));
+  for (const [table, a, when] of [['module_install_reports', 'ir', /ir\.reported_at >= t\.start AND \(t\.stop IS NULL OR ir\.reported_at < t\.stop\)/],
+                                  ['module_runtime_error_counts', 'ec', /ec\.day >= t\.start::date AND \(t\.stop IS NULL OR ec\.day <= t\.stop::date\)/]]) {
+    const sql = db.calls.find((c) => c.sql.includes(`FROM ${table} ${a}`)).sql;
+    assert.match(sql, /c1\.channel = 'tester'/, `${table}: the window opens on the tester channel`);
+    assert.match(sql, /c2\.channel <> 'tester' AND c2\.set_at > s\.start/, `${table}: and closes when it leaves it`);
+    assert.match(sql, when, `${table}: only reports inside the window`);
+    assert.ok(sql.includes(`NOT (${a}.holder_kind = 'builder' AND ${a}.holder_ref = m.author_id::text)`), `${table}: excludes the author`);
+  }
+  const insert = db.calls.find((c) => /INSERT INTO module_assessment_signals/.test(c.sql) && c.params[1] === 'tester_feedback');
+  assert.deepEqual(insert.params.slice(0, 5), [5, 'tester_feedback', 'scored', res.signals.tester_feedback.score, 4]);
+});
+
 // ---- the migration: there is nowhere to put anything but counts ----
 
 test('core_273: three additive tables whose columns hold counts and codes only', () => {

package/tests/reward_mode_surfacing.mjs

@@ -136,14 +136,27 @@ function loadBrandApply(rewardBlock) {
 const SHIPPED_TASK = { status: 'shipped', credits_awarded: 0, credits_reward: 60 };
 const READY_TASK = { status: 'ready', credits_reward: 60 };
 
-test('hall: cost-plus-only keeps "Est." on a SHIPPED task (the 60 is not a payout)', () => {
+// task 1004781 — a settled task shows what it was PAID, never its estimate:
+// the 60 is not a payout, so a shipped task with nothing in the ledger is 0,
+// and that 0 is an actual figure (plain label). Only live work is "Est.".
+test('hall: cost-plus-only shows a SHIPPED task as what it paid (0), not the 60 estimate', () => {
   const B = loadBrandApply(CPO);
-  assert.equal(B.taskCreditLabel(SHIPPED_TASK), 'credits Est.',
-    'dropping "Est." presents the unpaid estimate as the real payout');
+  assert.equal(B.taskCreditValue(SHIPPED_TASK), 0, 'the estimate must never stand in for a payout');
+  assert.equal(B.taskCreditLabel(SHIPPED_TASK), 'credits');
+  assert.equal(B.taskCreditValue({ ...SHIPPED_TASK, credits_awarded: 7 }), 7, 'a real payout shows as itself');
+  assert.equal(B.taskCreditValue(READY_TASK), 60, 'live work keeps its estimate');
   assert.equal(B.taskCreditLabel(READY_TASK), 'credits Est.');
   assert.equal(B.perTaskCredit(), false);
 });
 
+test('hall: a settled task never falls back to its estimate, on any reward mode', () => {
+  for (const mode of [CPO, PAYS, undefined]) {
+    const B = loadBrandApply(mode);
+    assert.equal(B.taskCreditValue(SHIPPED_TASK), 0);
+    assert.equal(B.taskCreditValue({ status: 'confirmed', credits_reward: 30 }), 0, 'no ledger figure ⇒ 0');
+  }
+});
+
 test('hall: a PAYING instance keeps the original settled/unsettled split', () => {
   const B = loadBrandApply(PAYS);
   assert.equal(B.taskCreditLabel(SHIPPED_TASK), 'credits', 'settled ⇒ plain label, unchanged');

package/tests/sky_read.mjs

@@ -56,14 +56,14 @@ await test('the shape: wells carry their criteria and their compact tasks; edges
   assert.equal(w1.created_at, '2026-09-01T00:00:00.000Z');
   // task 1004402: each ring also carries its UAT state + backend-only flag (ADR 0351).
   assert.deepEqual(w1.criteria, [{ id: '10', criterion_id: 'slug-10', criterion_md: 'Criterion 10', satisfied: false, backend_only: false, task_ids: ['100', '101'], pending_review: false, uat_state: 'open' }]);
-  assert.deepEqual(w1.tasks[0], { id: '100', title: 'Task 100', status: 'shipped', credits_reward: 30, created_on: '2026-09-02', idea_id: '555' });
+  assert.deepEqual(w1.tasks[0], { id: '100', title: 'Task 100', status: 'shipped', credits_reward: 30, credits_awarded: 0, created_on: '2026-09-02', idea_id: '555' });
   assert.equal(w1.tasks[1].idea_id, null, 'a task not born of an idea carries null, not an empty string');
   assert.deepEqual(out.goals[1].criteria[0].task_ids, [], 'a criterion with no linked task is an empty ring, not a missing one');
 });
 
 await test('nothing but the compact fields rides on a task — no description, no value summary, no notes', () => {
   const out = shapeSky({ goals: [g(1)], extras: [x(1)], tasks: [t(1, 1, { description: 'long prose', value_summary: 'more prose', notes: 'and more' })] });
-  assert.deepEqual(Object.keys(out.goals[0].tasks[0]).sort(), ['created_on', 'credits_reward', 'id', 'idea_id', 'status', 'title']);
+  assert.deepEqual(Object.keys(out.goals[0].tasks[0]).sort(), ['created_on', 'credits_awarded', 'credits_reward', 'id', 'idea_id', 'status', 'title']);
 });
 
 await test('a ring or a task under a goal that is not a well is dropped, not drawn to nowhere', () => {
@@ -177,6 +177,17 @@ await test('the criterion→task join is read ONCE for every goal-bearing criter
   assert.match(crit[0].sql, /LEFT JOIN tasks t\s+ON t\.id = tc\.task_id/, 'a criterion with no task still arrives (the rollup\'s LEFT JOIN)');
 });
 
+// task 1004781 — the sky sizes wells by what the ledger PAID, so the read
+// carries the payout (the shared subquery, settled-only) beside the estimate.
+await test('a task carries what the ledger paid for it, from the shared payout subquery', async () => {
+  const out = shapeSky({ goals: [g(1)], extras: [x(1)], tasks: [t(100, 1, { status: 'shipped', credits_awarded: '7' })] });
+  assert.equal(out.goals[0].tasks[0].credits_awarded, 7);
+  const pool = fakePool();
+  await skyRows({}, { pool });
+  const tq = pool.calls.find((c) => /FROM tasks t\s+JOIN goals g/.test(c.sql));
+  assert.match(tq.sql, /FROM credit_log cl[\s\S]*AS credits_awarded/);
+});
+
 await test('the task query is compact by construction: no description, no value_summary, and the date is truncated in SQL', async () => {
   const pool = fakePool();
   await skyRows({}, { pool });