@bongos/core 1.19.1065 → 1.19.1067

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();

package/tests/grader_reader_lens.mjs

@@ -216,36 +216,28 @@ test('docs/voice.md exists — the lens has a standard to judge against', () =>
   }
 });
 
-// ---- 7. THE DONE-WHEN CLAUSE THAT LIVES IN ANOTHER FILE ---------------------
+// ---- 7. THE ARTIST REVIEW THIS LENS WAS PAIRED WITH IS GONE -----------------
+//
+// Task 1003977 turned STEP 1 of the per-ship artist review into "coach the
+// reader", because this lens was listening. Tweak Mode removed that review
+// (task 1004325 / BV2.TW14, ADR 0341 D9): a ship now files no artist review at
+// all. The lens stays, scoped by the same predicate, which cascade.js still
+// exports for exactly this consumer.
 
-test('the artist review now coaches the reader, because there is a lens listening', () => {
-  // The task's own DONE WHEN: "Then STEP 1 of the artist review reverts to true
-  // coaching — see the comment in modules/lifecycle/cascade.js, which says so
-  // and asks not to be reverted early." The interim wording was explicitly a
-  // signal for which world we are in, so shipping the lens without turning it
-  // leaves the instruction to artists describing a panel that no longer exists.
-  const { artistReviewBody } = require('../modules/lifecycle/cascade.js');
-  const body = artistReviewBody({ id: '1234' });
-  assert.match(body, /COACH THE READER/, 'STEP 1 asks for coaching again');
-  assert.match(body, /docs\/voice\.md/, 'and names the standard to coach against');
-  assert.ok(!/none of them reads a sentence/.test(body),
-    'the interim claim that no lens reads a sentence is gone — it is no longer true');
-  // Still a request, never a gate (ADR 0241) — unchanged by this task.
-  assert.match(body, /REQUEST, not a gate/);
+test('the per-ship artist review is gone, and the lens keeps its scope predicate', () => {
+  const cascade = require('../modules/lifecycle/cascade.js');
+  assert.equal(cascade.artistReviewBody, undefined, 'no review body is left to coach from');
+  assert.equal(cascade.CASCADES.some((r) => r.key === 'artist-review-on-ship'), false);
+  assert.equal(cascade.hasCopyOrVisualWork, hasCopyOrVisualWork,
+    'the lens is scoped by cascade.js\'s own export, not a copy of it');
 });
 
-test('the cascade and the copy lens cover the SAME set by construction', () => {
-  // Both key off hasCopyOrVisualWork, so an artist review exists for exactly
-  // the ships a reader ran on. If these ever diverge, an artist is asked to
-  // coach a lens that never looked.
-  const cascadeSrc = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'cascade.js'), 'utf8');
+test('the copy lens is scoped by the files the work changed', () => {
   const shipSrc = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-grade.js'), 'utf8');
-  assert.match(cascadeSrc, /hasCopyOrVisualWork/);
   assert.match(shipSrc, /hasCopyOrVisualWork/);
-  // Task 1004201: BOTH consumers hand the predicate the files the work changed,
-  // so an unlabelled UI ship gets the lens at grade time AND the review on ship.
+  // Task 1004201: the grader hands the predicate the files the work changed, so
+  // an unlabelled UI ship gets the lens at grade time.
   assert.match(shipSrc, /hasCopyOrVisualWork\(task, changedFiles\)/, 'the grader passes its own diff');
-  assert.match(cascadeSrc, /hasCopyOrVisualWork\(t, \(ctx \|\| \{\}\)\.changedFiles\)/, 'the cascade passes the merged PR');
   const unlabelled = { module_key: null, discipline: 'engineer' };
   assert.equal(hasCopyOrVisualWork(unlabelled, ['modules/hall-ui/public/goal-forest-lib.js']), true);
   assert.equal(hasCopyOrVisualWork(unlabelled, ['modules/hall-ui/module.json', 'scripts/gds/claim.js']), false);

package/tests/removal_verdict.mjs

@@ -62,8 +62,11 @@ await test('the prefix does NOT match the other cascade rule', () => {
   // separating a removal question from an artist review. If it ever widened, a
   // Confirm button would appear on a copy review and answering it would record a
   // removal verdict about work nobody proposed removing.
-  const artist = cascade.CASCADES.find((r) => r.key === 'artist-review-on-ship');
-  const artistRef = cascade.cascadeSourceRef(artist.key, SHIP);
+  //
+  // The artist rule itself was removed by Tweak Mode (TW14, ADR 0341 D9), but the
+  // reviews it filed are still rows on the board under its key, so the key is
+  // spelled here rather than read from CASCADES.
+  const artistRef = cascade.cascadeSourceRef('artist-review-on-ship', SHIP);
   assert.ok(!artistRef.startsWith(proposals.PROPOSAL_SOURCE_REF_PREFIX));
   assert.equal(proposals.shipTaskIdFromSourceRef(artistRef), null);
 });

package/tests/tweak_replaces_artist_review.mjs

@@ -0,0 +1,170 @@
+// tests/tweak_replaces_artist_review.mjs — Tweak Mode replaces the per-ship
+// artist review, the WHOLE path (task 1004325 / BV2.TW14, ADR 0341 D8 and D9).
+//
+// The done-when: "a ship changing a page's text files no artist review and the
+// page reads changed-since". Two halves, and they meet at one ship:
+//
+//   1. THE SHIP FILES NOTHING. The real cascade runner, with the real
+//      production table, the ship's real changed files and the artist gate at
+//      'strict' (the level that used to file AND hold), creates no task.
+//   2. THE PAGE READS CHANGED-SINCE ANYWAY, with no write. The real copy-desk
+//      route over the real lifecycle port's SQL (a fake pool), reading the page
+//      artifacts from disk: before the ship the page matches its last round;
+//      after it, the page's reading has moved, drift names the changed line, and
+//      the ship itself is listed as what changed it, found by its touches.
+//
+// "No write" is checked twice: the cascade's createTask is never called, and
+// the fake pool refuses any SQL that is not one of the two reads, so an INSERT
+// or UPDATE anywhere on the read path reds here.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+
+const F = require('../modules/copy-desk/tests/fixtures/page-tweak.cjs');
+const cascade = require('../modules/lifecycle/cascade.js');
+const gate = require('../src/bongos/artist-gate.js');
+const api = require('../src/module-api.js');
+
+// THE SHIP. An engineer rewords the studio greeting ("Welcome home" becomes
+// "Welcome back") after the page's first round shipped. Its touches meet the
+// studio page's files, and it is copy/visual work by every measure the old rule
+// used: a hall-ui module ship that changed a page file.
+const SHIP = {
+  id: '555', title: 'Reword the studio greeting', status: 'shipped',
+  discipline: 'engineer', kind: 'feature', source: 'manual', module_key: 'hall-ui',
+  version_id: 'BONGOS-V2', goal_id: '1000095',
+  touches: ['modules/hall-ui/public/studio.html'],
+  shipped_at: new Date('2026-09-22T09:00:00Z'),
+};
+
+// Every SQL the page read sends, so the test can say none of it wrote.
+const seen = [];
+const flat = (sql) => String(sql).replace(/\s+/g, ' ').trim();
+api.pool = {
+  async query(sql, params = []) {
+    const q = flat(sql);
+    seen.push({ q, params });
+    if (/FROM tasks t LEFT JOIN task_grades g/.test(q)) return { rows: F.TASKS };
+    if (/t\.touches && \$1::text\[\]/.test(q)) {
+      // The real query's predicate, applied to the one ship: shipped after the
+      // page's last round, touching one of the page's files.
+      const files = new Set(params[0]);
+      const hit = SHIP.shipped_at > new Date(params[1]) && SHIP.touches.some((t) => files.has(t));
+      return { rows: hit ? [{ id: SHIP.id, title: SHIP.title, shipped_at: SHIP.shipped_at }] : [] };
+    }
+    throw new Error(`unexpected SQL on the page read: ${q.slice(0, 120)}`);
+  },
+};
+api.requireBuilder = (req, res, next) => { req.builder = { id: F.ALICE.id, rank: 'thetes' }; next(); };
+
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('lifecycle')) seams.registerProvider('lifecycle', require('../modules/lifecycle/lifecycle.js'));
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+
+const pageData = require('../modules/copy-desk/page-data.js');
+const express = require('express');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRouter = require('../modules/copy-desk/routes/copy-desk.js');
+
+const app = express();
+app.use(attachFail);
+app.use(buildRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const base = `http://127.0.0.1:${server.address().port}`;
+async function get(p) {
+  const r = await fetch(base + p);
+  return { status: r.status, body: await r.json() };
+}
+
+// The studio's reading BEFORE the ship says exactly what its first round left
+// ("Welcome home", "Resume"); AFTER it is the fixture's (the greeting moved).
+// The shared shell line differs on both sides, and drift must ignore it.
+const studioAfter = F.READINGS.pages.find((p) => p.id === 'builders:studio');
+const studioBefore = {
+  ...studioAfter,
+  reading_hash: 'studio-before',
+  lines: studioAfter.lines.map((l) => (l.key === 'L0002' ? { ...l, text: 'Welcome home' } : l)),
+};
+const readingsWith = (studio) => ({ ...F.READINGS, pages: F.READINGS.pages.map((p) => (p.id === studio.id ? studio : p)) });
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tweak-replaces-review-'));
+const root = (name, readings) => {
+  const dir = path.join(tmp, name);
+  fs.mkdirSync(path.join(dir, 'docs'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'docs', 'page-inventory.json'), JSON.stringify(F.INVENTORY));
+  fs.writeFileSync(path.join(dir, 'docs', 'page-readings.json'), JSON.stringify(readings));
+  return dir;
+};
+const BEFORE = root('before', readingsWith(studioBefore));
+const AFTER = root('after', readingsWith(studioAfter));
+
+const { test, summary } = makeRunner();
+
+try {
+  await test('before the ship, the studio matches its last round: tweaked, no drift', async () => {
+    pageData._setRoot(BEFORE);
+    const { status, body } = await get('/copy-desk/pages/builders:studio');
+    assert.equal(status, 200);
+    assert.equal(body.status_label, 'Text tweaked 1x');
+    assert.equal(body.drift.changed, false);
+  });
+
+  await test('the ship that rewords the page files NO artist review, at the strictest gate', async () => {
+    const created = [];
+    const report = await cascade.runCascadesForShip({ id: SHIP.id }, {
+      getTask: async () => SHIP,
+      findTaskBySourceRef: async () => null,
+      createTask: async (spec) => { created.push(spec); return { id: '9999' }; },
+      artistGateMode: () => 'strict',
+      changedFiles: async () => ({ paths: SHIP.touches, truncated: false }),
+      removalCandidates: async () => ({ removals: [] }),
+    });
+    assert.deepEqual(report.errors, []);
+    assert.deepEqual(created, [], 'nothing is filed: no review task, no marker, nothing');
+    assert.equal(created.some((s) => gate.isArtistReview({ source: s.source, source_ref: s.sourceRef })), false);
+    // It is still copy/visual work: the grader's reader lens still runs on it.
+    assert.equal(cascade.hasCopyOrVisualWork(SHIP, SHIP.touches), true);
+  });
+
+  await test('after the ship, the page reads changed-since, and names the ship, with no write', async () => {
+    pageData._setRoot(AFTER);
+    seen.length = 0;
+    const { status, body } = await get('/copy-desk/pages/builders:studio');
+    assert.equal(status, 200);
+    assert.equal(body.drift.known, true);
+    assert.equal(body.drift.changed, true, 'the page reads "changed since last tweak"');
+    assert.deepEqual(body.drift.changed_lines, [{ key: 'L0002', section: 'greeting', text: 'Welcome back' }]);
+    assert.deepEqual(body.drift.removed_lines, ['Welcome home']);
+    assert.deepEqual(body.drift.ships.map((s) => s.task_id), [SHIP.id], 'the ship is what changed it');
+    assert.equal(body.status_label, 'Text tweaked 1x', 'drift never lowers the count');
+    // Derived, never stored: only the two reads ran.
+    assert.ok(seen.length > 0);
+    for (const s of seen) assert.match(s.q, /^(WITH .*)?SELECT /, `a read, never a write: ${s.q.slice(0, 80)}`);
+  });
+
+  await test('the page list carries the same drift, which is what the recommendation ranks on', async () => {
+    pageData._setRoot(AFTER);
+    const list = await get('/copy-desk/pages');
+    const studio = list.body.pages.find((p) => p.id === 'builders:studio');
+    assert.equal(studio.drift.changed, true);
+    assert.equal(studio.drift.changed_count, 1);
+  });
+} finally {
+  pageData._setRoot(null);
+  server.closeAllConnections();
+  await new Promise((resolve) => server.close(resolve));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// Let the closed sockets finish closing before summary() calls process.exit: on
+// Windows an exit while a handle is mid-close trips a libuv assertion (exit 127)
+// after every case has passed.
+await new Promise((resolve) => setTimeout(resolve, 100));
+summary();