@bongos/core 1.19.1064 → 1.19.1066

package/package-lock.json

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

package/package.json

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

@@ -7685,5 +7685,17 @@
       "id": "1004322",
       "text": "A session can now apply an artist's rewritten page. The new /tweak skill takes the next submitted page, applies every line in one pass, and photographs the page before and after, on a desktop and a phone, in light and dark, at"
     }
+  ],
+  "1.19.1065": [
+    {
+      "id": "1004323",
+      "text": "An artist can now approve a tweaked page from the studio. A new Approval queue button opens a glass panel that shows the applied page as real pictures, before and after, on desktop and phone, in light and dark, with the change"
+    }
+  ],
+  "1.19.1066": [
+    {
+      "id": "1004324",
+      "text": "When an artist's page rewrite is approved and goes live, the artist is now paid 30 credits for it, the same value an artist review used to carry. The payment lands at the moment the page ships, never at approval, and a page th"
+    }
   ]
 }

package/scripts/hall-preview/server.js

@@ -136,6 +136,9 @@ const FIXTURE_FALLBACKS = [
   // page id, since the editor shows one page. A page id carries a colon, which a
   // Windows file name cannot, so there is no per-id file to find first.
   [/^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/draft$/, 'copy-desk__pages__draft'],
+  // the Approval queue's renders (task 1004323): a round's named visuals, one
+  // fixture for any task id, as the editor read above serves any page.
+  [/^tasks\/\d+\/visuals$/, 'tasks__visuals'],
 ];
 
 // CANNED WRITES (task 1004321). The tweak editor's whole flow is writes (the
@@ -148,6 +151,10 @@ const CANNED_WRITES = [
   ['PUT', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/draft$/, 'copy-desk__pages__draft.put'],
   ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/submit$/, 'copy-desk__pages__submit.post'],
   ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/claim$/, 'copy-desk__pages__claim.post'],
+  // the Approval queue's two decisions (task 1004323), so the approved and
+  // sent-back lines the artboard draws render too.
+  ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/approve$/, 'copy-desk__pages__approve.post'],
+  ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/send-back$/, 'copy-desk__pages__send-back.post'],
 ];
 
 // A DATE THAT ROTS CANNOT DEMO AN AGE SIGNAL (task 1004041). The help-request
@@ -252,6 +259,17 @@ app.use((req, res, next) => {
   // frame, so the one thing being reviewed is the one thing you cannot see.
   // A generated stand-in; see scripts/hall-preview/task-visual.js.
   if (/^task-visuals\/[A-Za-z0-9._-]+$/.test(apiPath) && req.method === 'GET') {
+    // HALL_PREVIEW_VISUALS=<dir> serves a REAL image of that name from <dir>
+    // instead (task 1004323): the Approval queue's review sheet shows the renders
+    // /tweak really attached, copied under the fixture's names into a scratch
+    // dir. Nothing is committed; unset, every visual is the stand-in as before.
+    const realDir = process.env.HALL_PREVIEW_VISUALS;
+    const name = apiPath.slice('task-visuals/'.length);
+    const real = realDir && /^task-\d+-[0-9a-f]{16}\.(png|jpg)$/.test(name) ? path.join(realDir, name) : null;
+    if (real && fs.existsSync(real)) {
+      res.set({ 'content-type': name.endsWith('.png') ? 'image/png' : 'image/jpeg', 'cache-control': 'no-store' });
+      return res.end(fs.readFileSync(real));
+    }
     const png = require('./task-visual').placeholderPng();
     res.set({ 'content-type': 'image/png', 'cache-control': 'no-store' });
     return res.end(png);

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.1064'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.1066'; // 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('dev-box'); log.info('mounted');

package/tests/artist_page_credit.mjs

@@ -0,0 +1,272 @@
+// tests/artist_page_credit.mjs
+//
+// Task 1004324 / BV2.TW13, ADR 0341 D10: an approved page pays its ARTIST at
+// the land, as the artist reviews it replaced paid.
+//
+// The contract this pins, through the REAL db.shipTask and the REAL economy
+// writer over a small stateful ledger (tasks, claims, credit_log):
+//   * a shipped page tweak books ONE credit_log row, reason
+//     tweak.page_approved:<task id>, to the builder of the round's latest WEB
+//     claim, worth credits_reward x KIND_MULTIPLIERS[kind] (30 for a feature
+//     round at 30);
+//   * the shipper's per-task estimate (task.shipped) is NOT paid on a page
+//     tweak, so the per-task stream's total is the same as an ordinary ship's;
+//   * a self-applied round (the artist also ran /tweak) is one artist row;
+//   * rounding is the one multiplier rule, once;
+//   * a re-ship or a reconciler re-sweep books nothing a second time;
+//   * a sent-back round is never paid, and a re-applied round pays its artist,
+//     never either applier;
+//   * the lane is not withheld by cost-plus-only, and only an explicit
+//     artistCredit:false turns it off;
+//   * the reason prefix is the one the studio tally sums, and the tally reads
+//     the booked row as 30 credits.
+//
+// Run:  node tests/artist_page_credit.mjs
+
+import { strict as assert } from 'node:assert';
+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 () => [];
+achievements.reconcileBuilderAchievements = async () => [];
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+const credits = require('../modules/economy/credits.js');
+const db = require('../modules/lifecycle/db.js');
+const pageStatus = require('../modules/copy-desk/page-status.js');
+
+const { test, summary } = makeRunner();
+
+const ARTIST = '41';
+const APPLIER = '42';
+const APPLIER_2 = '43';
+const OTHER_ARTIST = '44';
+const RECONCILER = '999';
+const LAND_PROOF = { kind: 'proof', reason: 'test fixture: land proven' };
+
+// The claims a round collects, in order. A web claim has no worktree and no
+// session; the applier's CLI claim has a worktree.
+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 stateful ledger for one task. It answers the statements shipTask and the
+// artist writer send; credit_log is a real list, so the NOT EXISTS guards are
+// evaluated against what was actually booked.
+function ledger({ source = 'page-tweak', status = 'confirmed', creditsReward = 30, kind = 'feature', claims = [] } = {}) {
+  const state = {
+    task: { id: 7001, title: 'Tweak: Home (landing:index)', source, status, credits_reward: creditsReward, kind, shipped_by: null },
+    claims: claims.map((c, i) => ({ id: 9000 + i, released_at: 'earlier', ...c })),
+    credit_log: [],
+  };
+  const latest = (list) => list.slice().sort((a, b) => (a.claimed_at - b.claimed_at) || (a.id - b.id)).slice(-1)[0] || null;
+  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';
+      t.shipped_by = 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 (/^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 1 FROM credit_log WHERE task_id = \$1 AND reason = 'task\.shipped'/.test(s)) {
+      return { rows: state.credit_log.filter((r) => r.task_id === p[0] && r.reason === 'task.shipped').map(() => ({ one: 1 })) };
+    }
+    if (/^SELECT t\.source, t\.status, t\.credits_reward, t\.kind/.test(s)) {
+      if (p[0] !== t.id) return { rows: [] };
+      assert.match(s, /c\.worktree_name IS NULL AND c\.creator_session_id IS NULL/, 'the payee is read from WEB claims only');
+      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 (/WHERE NOT EXISTS \(SELECT 1 FROM credit_log WHERE task_id = \$2 AND reason = \$4\)/.test(s)
+        && state.credit_log.some((r) => r.task_id === task_id && r.reason === reason)) return { rows: [], rowCount: 0 };
+      if (/WHERE NOT EXISTS \(SELECT 1 FROM credit_log WHERE builder_id = \$1 AND reason = \$4\)/.test(s)
+        && state.credit_log.some((r) => r.builder_id === builder_id && r.reason === reason)) return { rows: [], rowCount: 0 };
+      state.credit_log.push({ builder_id, task_id, delta, reason, recorded_at: new Date().toISOString() });
+      return { rows: [], rowCount: 1 };
+    }
+    return { rows: [] };
+  });
+  return { pool, state };
+}
+
+const ship = (pool) => db.shipTask({ taskId: 7001, builderId: RECONCILER, landAssurance: LAND_PROOF }, { pool });
+const sent = (pool) => pool._client.queries.map((q) => String(q.sql).replace(/\s+/g, ' ').trim());
+const perTaskRows = (state) => state.credit_log.filter((r) => r.reason === 'task.shipped' || r.reason.startsWith('tweak.page_approved:'));
+
+// =========================================================================
+await test('a shipped page tweak pays its artist 30, on tweak.page_approved:<id>, and the shipper no estimate', async () => {
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  const out = await ship(pool);
+  assert.equal(out.status, 'shipped');
+  assert.equal(out.creditsAwarded, 0, 'the shipper is paid no per-task estimate on a page tweak');
+  assert.equal(String(out.creditedBuilderId), APPLIER, 'the applier is still the ship-credited builder (achievements, session reward)');
+  assert.deepEqual(state.credit_log.map((r) => [String(r.builder_id), r.task_id, r.delta, r.reason]),
+    [[ARTIST, 7001, 30, 'tweak.page_approved:7001']], 'exactly one row: the artist, the priced value, the tally reason');
+  assert.equal(out.artistCredit.reason, 'paid');
+  assert.equal(out.artistCredit.credited, 30);
+  assert.ok(!sent(pool).some((q) => /'task\.shipped'/.test(q)), 'the estimate path is never entered for a page tweak');
+});
+
+await test('self-applied: the artist also ran /tweak, and is paid one artist row, nothing doubled', async () => {
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(ARTIST, 2)] });
+  const out = await ship(pool);
+  assert.equal(String(out.creditedBuilderId), ARTIST);
+  assert.equal(state.credit_log.length, 1, 'one row, not an artist row plus an estimate row');
+  assert.equal(String(state.credit_log[0].builder_id), ARTIST);
+  assert.equal(state.credit_log[0].delta, 30);
+});
+
+await test('rounding: the priced value is credits_reward x the kind multiplier, rounded once', async () => {
+  for (const [reward, kind, want] of [[30, 'feature', 30], [25, 'bug', 30], [7, 'refactor', 6], [5, 'spike', 6], [3, 'cleanup', 2], [11, 'mystery', 11]]) {
+    const { pool, state } = ledger({ creditsReward: reward, kind, claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+    await ship(pool);
+    assert.equal(state.credit_log.length, 1, `${reward} x ${kind}: one row`);
+    assert.equal(state.credit_log[0].delta, want, `${reward} x ${kind} pays ${want}`);
+    assert.equal(state.credit_log[0].delta, credits.applyKindMultiplier(reward, kind).effective, 'the same rule as the estimate');
+  }
+});
+
+await test('a zero-reward round books nothing (no zero-value row that reads like a payment)', async () => {
+  const { pool, state } = ledger({ creditsReward: 0, claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  const out = await ship(pool);
+  assert.equal(state.credit_log.length, 0);
+  assert.equal(out.artistCredit.reason, 'zero_value');
+});
+
+await test('the per-task stream total is conserved: a page tweak pays the artist what the ordinary ship paid the shipper', async () => {
+  for (const [reward, kind] of [[30, 'feature'], [25, 'bug'], [7, 'refactor']]) {
+    const ordinary = ledger({ source: null, creditsReward: reward, kind, claims: [cli(APPLIER, 2)] });
+    await ship(ordinary.pool);
+    const tweak = ledger({ creditsReward: reward, kind, claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+    await ship(tweak.pool);
+    const sum = (st) => perTaskRows(st).reduce((a, r) => a + r.delta, 0);
+    const ordinaryRows = perTaskRows(ordinary.state);
+    // An instance in cost-plus-only books no ordinary estimate at all; the
+    // equality then holds against what the estimate WOULD have been.
+    const estimate = ordinaryRows.length ? sum(ordinary.state) : credits.applyKindMultiplier(reward, kind).effective;
+    assert.equal(sum(tweak.state), estimate, `${reward} x ${kind}: the same total, moved to the artist`);
+    assert.ok(!perTaskRows(tweak.state).some((r) => String(r.builder_id) === APPLIER), 'the applier gets no per-task row');
+    assert.ok(!sent(ordinary.pool).some((q) => /^SELECT t\.source, t\.status/.test(q)), 'an ordinary ship never asks the artist lane');
+  }
+});
+
+await test('idempotent: a re-ship or a reconciler re-sweep books nothing a second time', async () => {
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  await ship(pool);
+  // The shipped flip is terminal, so a second shipTask throws before paying.
+  await assert.rejects(() => ship(pool), (e) => e.code === 'TASK_NOT_CONFIRMED');
+  // And the writer itself, asked again inside some later transaction, refuses.
+  const again = await credits.awardArtistPageCredit(pool._client, { taskId: 7001, config: credits.rewardPolicy({}) });
+  assert.equal(again.reason, 'already_paid');
+  assert.equal(again.credited, 0);
+  assert.equal(state.credit_log.length, 1, 'still one row');
+});
+
+await test('one payment per ROUND: a payee that reads differently on a re-sweep is still refused', async () => {
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  await ship(pool);
+  state.claims.push({ id: 9100, released_at: 'later', ...web(OTHER_ARTIST, 3) });
+  const again = await credits.awardArtistPageCredit(pool._client, { taskId: 7001, config: credits.rewardPolicy({}) });
+  assert.equal(again.reason, 'already_paid', 'keyed on (task, reason), not (builder, reason)');
+  assert.equal(state.credit_log.length, 1);
+});
+
+await test('a sent-back round is never paid: it sits at ready, its ship is refused, and the writer refuses too', async () => {
+  const { pool, state } = ledger({ status: 'ready', claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  await assert.rejects(() => ship(pool), (e) => e.code === 'TASK_NOT_CONFIRMED');
+  const direct = await credits.awardArtistPageCredit(pool._client, { taskId: 7001, config: credits.rewardPolicy({}) });
+  assert.equal(direct.reason, 'not_shipped', 'a round must read shipped in the transaction to be paid');
+  for (const s of ['completed', 'confirmed', 'active', 'abandoned']) {
+    state.task.status = s;
+    const r = await credits.awardArtistPageCredit(pool._client, { taskId: 7001, config: credits.rewardPolicy({}) });
+    assert.equal(r.reason, 'not_shipped', `${s} is not paid`);
+  }
+  assert.equal(state.credit_log.length, 0);
+});
+
+await test('sent back, re-applied by someone else, approved and landed: the artist is paid once, neither applier', async () => {
+  // web (artist writes) -> CLI (applier 1, sent back, released) -> CLI (applier 2)
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(APPLIER, 2), cli(APPLIER_2, 3)] });
+  const out = await ship(pool);
+  assert.equal(String(out.creditedBuilderId), APPLIER_2, 'the landing applier is the ship-credited builder');
+  assert.deepEqual(state.credit_log.map((r) => [String(r.builder_id), r.delta]), [[ARTIST, 30]]);
+});
+
+await test('the payee is the LATEST web claim: an artist who resumed the draft after a send-back is the one paid', async () => {
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(APPLIER, 2), web(OTHER_ARTIST, 3), cli(APPLIER, 4)] });
+  await ship(pool);
+  assert.deepEqual(state.credit_log.map((r) => String(r.builder_id)), [OTHER_ARTIST],
+    'the TW05 reads name the same builder as the round\'s artist');
+});
+
+await test('a page tweak with no web claim pays nobody rather than guessing', async () => {
+  const { pool, state } = ledger({ claims: [cli(APPLIER, 2)] });
+  const out = await ship(pool);
+  assert.equal(out.artistCredit.reason, 'no_artist');
+  assert.equal(state.credit_log.length, 0, 'and the applier is not paid the estimate in its place');
+});
+
+await test('the writer reads the task itself: an ordinary task handed to it is refused', async () => {
+  const { pool, state } = ledger({ source: 'cascade', status: 'shipped', claims: [web(ARTIST, 1)] });
+  const r = await credits.awardArtistPageCredit(pool._client, { taskId: 7001, config: credits.rewardPolicy({}) });
+  assert.equal(r.reason, 'not_a_page_tweak');
+  const missing = await credits.awardArtistPageCredit(pool._client, { taskId: 1, config: credits.rewardPolicy({}) });
+  assert.equal(missing.reason, 'not_found');
+  assert.equal(state.credit_log.length, 0);
+});
+
+await test('the artist lane: cost-plus-only does not withhold it; only an explicit artistCredit:false does', async () => {
+  const p = credits.rewardPolicy({ mode: 'cost-plus-only' });
+  assert.equal(p.perTaskCredit, false);
+  assert.equal(p.artistCredit, true, 'a different craft\'s pay, not the builder estimate');
+  assert.equal(credits.rewardPolicy({}).artistCredit, true, 'absent -> on');
+  for (const v of [true, 1, 'yes', undefined, null]) assert.equal(credits.rewardPolicy({ artistCredit: v }).artistCredit, true);
+  assert.equal(credits.rewardPolicy({ artistCredit: false }).artistCredit, false, 'explicit opt-out');
+
+  const { pool, state } = ledger({ status: 'shipped', claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  const paid = await credits.awardArtistPageCredit(pool._client, { taskId: 7001, config: p });
+  assert.equal(paid.credited, 30, 'paid under cost-plus-only');
+  const off = ledger({ status: 'shipped', claims: [web(ARTIST, 1)] });
+  const r = await credits.awardArtistPageCredit(off.pool._client, { taskId: 7001, config: credits.rewardPolicy({ artistCredit: false }) });
+  assert.equal(r.reason, 'artist_lane_off');
+  assert.equal(off.state.credit_log.length, 0);
+  assert.equal(state.credit_log.length, 1);
+});
+
+await test('the booked row is what the studio tally sums: same prefix, and it reads as 30 credits', async () => {
+  assert.equal(credits.ARTIST_PAGE_REASON_PREFIX, pageStatus.TALLY_REASON_PREFIX,
+    'economy writes and copy-desk reads the same prefix (restated in each, since a module cannot require another)');
+  const { pool, state } = ledger({ claims: [web(ARTIST, 1), cli(APPLIER, 2)] });
+  await ship(pool);
+  const tally = pageStatus.composeTally({ builderId: ARTIST, tasks: [], creditRows: state.credit_log, now: new Date() });
+  assert.equal(tally.credits, 30);
+  assert.equal(tally.this_week, 30);
+  const applierTally = pageStatus.composeTally({ builderId: APPLIER, tasks: [], creditRows: state.credit_log.filter((r) => String(r.builder_id) === APPLIER), now: new Date() });
+  assert.equal(applierTally.credits, 0);
+});
+
+await test('the reward port exposes the writer, delegated so a stub bites at call time', async () => {
+  const port = require('../modules/economy/reward.js');
+  assert.equal(typeof port.awardArtistPageCredit, 'function');
+  const real = credits.awardArtistPageCredit;
+  credits.awardArtistPageCredit = async () => ({ credited: 0, reason: 'stubbed' });
+  try {
+    assert.equal((await port.awardArtistPageCredit({}, { taskId: 1 })).reason, 'stubbed');
+  } finally {
+    credits.awardArtistPageCredit = real;
+  }
+});
+
+summary();