@bongos/core 1.19.1066 → 1.19.1067

package/modules/lifecycle/tests/cascade.mjs

@@ -11,10 +11,10 @@
 //   3. it says where it came from
 //   4. it files at backlog, never ready
 //
-// The production table ships EMPTY (R04 writes the first rule), so the rules
-// below are the test's OWN declarations — which is also the point: a mechanism
-// proved by a rule its consumer has not written yet is proved against the
-// contract rather than against one example.
+// The mechanism is proved by the test's OWN declarations, not a production
+// rule — which is also the point: a mechanism proved against the contract
+// rather than one example survives its rules coming and going (the artist
+// review, R04's, was removed by TW14).
 //
 // DB-free: the runner takes its three database calls as injected functions.
 
@@ -185,7 +185,13 @@ await test('the production table is valid, and a duplicate key is refused', () =
   assert.ok(shape.some((p) => /body/.test(p)));
 });
 
-// --- the first production rule: the artist review (R04, task 1003115) --------
+// --- the artist review is GONE: Tweak Mode replaced it (TW14, ADR 0341 D9) ----
+//
+// R04 (task 1003115) wrote `artist-review-on-ship`, which filed an artist review
+// for every copy/visual ship. Task 1004325 removed it: a ship that changes a
+// page's words writes NOTHING, and the page reads "changed since last tweak"
+// because drift is derived (D8). tests/tweak_replaces_artist_review.mjs proves
+// that second half on the whole path; these pin the first.
 
 const shippedCopy = (over = {}) => ({
   id: '7001', version_id: 'BONGOS-V1', goal_id: '1000074',
@@ -194,66 +200,59 @@ const shippedCopy = (over = {}) => ({
   ...over,
 });
 
-await test('the artist review is keyed and disciplined, and the table stays well-formed', () => {
-  // This pinned CASCADES.length === 1 until task 1004090 appended the removal
-  // proposal (BV2.R15). A count is the wrong pin for a table whose whole contract
-  // is "extend by appending an entry" (ADR 0242) — it fails on the one change it
-  // is meant to permit, and says nothing about WHICH rules are there.
-  //
-  // So it pins the rule by KEY instead, and pins the SET of keys separately below:
-  // a rule vanishing and a rule being added are different events and should fail
-  // differently.
-  const r = cascade.CASCADES.find((x) => x.key === 'artist-review-on-ship');
-  assert.ok(r, 'the artist review rule is gone from CASCADES');
-  assert.equal(r.discipline, 'artist', 'the review is FOR the artist, whatever role shipped the work');
-  assert.equal(r.kind, 'unclassified', 'a valid kind — not the invalid "chore" the spec used to default to');
-  assert.deepEqual(cascade.validateCascades(), [], 'and the shipped table is well-formed');
+// A test rule that records the ctx the runner handed it, so the runner's
+// resolution of policy and changed files is still pinned with no production
+// rule reading either.
+const ctxProbe = () => {
+  const seen = [];
+  return {
+    seen,
+    rule: {
+      key: 'test-ctx-probe',
+      discipline: 'artist',
+      when: (t, ctx) => { seen.push(ctx); return false; },
+      title: () => 'never',
+      body: () => 'never',
+    },
+  };
+};
+
+await test('the artist review rule is gone from CASCADES, and the table stays well-formed', () => {
+  assert.equal(cascade.CASCADES.find((x) => x.key === 'artist-review-on-ship'), undefined,
+    'Tweak Mode replaced the per-ship review (ADR 0341 D9)');
+  assert.equal(cascade.artistReviewBody, undefined, 'its body went with it');
+  assert.deepEqual(cascade.validateCascades(), [], 'the shipped table is well-formed');
 });
 
 await test('the production rule set is exactly what is declared', () => {
-  // The other half of the pin above: adding a rule is a deliberate act, so it
-  // should have to be recorded here. Duplicate keys would collide on source_ref
-  // and silently suppress one another, which validateCascades already refuses.
-  assert.deepEqual(
-    cascade.CASCADES.map((r) => r.key).sort(),
-    ['artist-review-on-ship', 'removal-proposed-on-ship'],
-  );
+  // Adding a rule is a deliberate act, so it should have to be recorded here,
+  // and a rule vanishing fails here too. Duplicate keys would collide on
+  // source_ref and silently suppress one another, which validateCascades refuses.
+  assert.deepEqual(cascade.CASCADES.map((r) => r.key).sort(), ['removal-proposed-on-ship']);
+});
+
+await test('a copy/visual ship files NO artist review, at every artist-gate level', () => {
+  for (const ctx of [undefined, {}, { artistGate: 'strict' }, { artistGate: 'advisory' }, { artistGate: 'off' }, { artistGate: undefined }]) {
+    const { matched, errors } = cascade.cascadesFor(shippedCopy(), cascade.CASCADES, ctx);
+    assert.deepEqual(errors, []);
+    assert.equal(matched.length, 0, `nothing filed with ctx ${JSON.stringify(ctx)}`);
+  }
+  // Every shape that USED to file one: a copy proposal landing, an artist's own
+  // work, an unlabelled ship that changed a page file, and a truncated file list.
+  const shapes = [
+    [shippedCopy({ module_key: null, source: 'copy-proposal' }), {}],
+    [shippedCopy({ module_key: null, discipline: 'artist' }), {}],
+    [shippedCopy({ module_key: null }), { changedFiles: ['modules/hall-ui/public/studio.html'] }],
+    [shippedCopy({ module_key: null }), { changedFiles: [], changedFilesTruncated: true }],
+  ];
+  for (const [task, ctx] of shapes) {
+    assert.equal(cascade.cascadesFor(task, cascade.CASCADES, ctx).matched.length, 0, JSON.stringify(ctx));
+  }
 });
 
-await test('a copy/visual ship generates the two-step artist review', () => {
-  const { matched } = cascade.cascadesFor(shippedCopy());
-  assert.equal(matched.length, 1);
-  const spec = matched[0].spec;
-  assert.equal(spec.discipline, 'artist');
-  assert.equal(spec.kind, 'unclassified');
-  assert.equal(spec.status, 'backlog', 'a request that triage may dismiss — not claimable, not nagging');
-  assert.match(spec.title, /7001/);
-  // Both steps, and both routes of step 2, are in the body.
-  //
-  // STEP 1's label tracks ADR 0298 (task 1003937), and it has now turned twice.
-  // It first read "REVIEW THE GRADER … coach it", which asked for something no
-  // artist could do: the panel's four lenses read completion, code quality,
-  // security and runtime cost, so there was no copy verdict to coach. It was
-  // rewritten to ask for the RECORD instead, as an explicitly INTERIM wording,
-  // pinned here so a well-meaning copy-edit could not restore the unfollowable
-  // version without reading why.
-  //
-  // Task 1003977 shipped the advisory reader lens and the voice guide it waited
-  // on (task 1003976), so the step is coaching again — and this pin moves with
-  // it. The two must turn TOGETHER: the wording is the signal for which world
-  // we are in, so a body that still said "no lens reads a sentence" after the
-  // lens landed would send every artist looking for a counterpart that is
-  // sitting right there in the grade record.
-  assert.match(spec.description, /STEP 1 — COACH THE READER/);
-  assert.match(spec.description, /docs\/voice\.md/, 'and names the written standard to coach against');
-  assert.doesNotMatch(spec.description, /none of them reads a sentence/,
-    'the interim claim is gone — it stopped being true when the reader shipped');
-  assert.match(spec.description, /ADR 0298/, 'the step names the decision that shaped it');
-  assert.match(spec.description, /STEP 2 — REMAKE OR TWEAK/);
-  assert.match(spec.description, /OUTSIDE the AI chat/);
-  assert.match(spec.description, /WITH it/);
-  assert.match(spec.description, /DISMISS this in triage/);
-  assert.match(spec.description, /blocks nothing that shipped/, 'it says out loud that it is not a gate');
+await test('hasCopyOrVisualWork STAYS, because the grader\'s reader lens is scoped by it', () => {
+  assert.equal(typeof cascade.hasCopyOrVisualWork, 'function');
+  assert.equal(cascade.hasCopyOrVisualWork(shippedCopy()), true, 'a hall-ui ship is still copy/visual work');
 });
 
 await test('"copy or visuals" is a NARROW predicate — three ways in, and a default of no', () => {
@@ -262,49 +261,33 @@ await test('"copy or visuals" is a NARROW predicate — three ways in, and a def
   assert.equal(H(shippedCopy({ module_key: 'art-pipeline' })), true);
   assert.equal(H(shippedCopy({ module_key: null, source: 'copy-proposal' })), true, 'a landed copy proposal');
   assert.equal(H(shippedCopy({ module_key: null, source: 'manual', discipline: 'artist' })), true, 'work an artist did');
-  // The default is NO — a backend/infra ship is not an artist review.
+  // The default is NO — a backend/infra ship is not copy/visual work.
   assert.equal(H(shippedCopy({ module_key: 'lifecycle', discipline: 'engineer', source: 'manual' })), false);
   assert.equal(H(shippedCopy({ module_key: null, discipline: 'engineer', source: 'manual' })), false);
   assert.equal(H(null), false);
 });
 
-await test('THE ANTI-RECURSION GUARD: an artist review shipping does NOT generate a review of itself', () => {
-  // The generated review is discipline:'artist' + source:'cascade'. Its own
-  // predicate (discipline artist) would match — so without the source guard it
-  // would cascade forever. This is the test that proves it is a single hop.
-  const reviewTaskThatShipped = shippedCopy({
-    discipline: 'artist', source: cascade.CASCADE_SOURCE, module_key: null, id: '7100',
+await test('THE ANTI-RECURSION GUARD: a cascade-generated task shipping matches no production rule', () => {
+  // The removal rule's guard: even a cascade task whose ship deleted earlier
+  // work files nothing, so generation stays a single hop.
+  const cascaded = shippedCopy({ discipline: 'artist', source: cascade.CASCADE_SOURCE, module_key: null, id: '7100' });
+  const { matched } = cascade.cascadesFor(cascaded, cascade.CASCADES, {
+    removals: [{ taskId: '42', paths: ['a.js'] }],
   });
-  const { matched } = cascade.cascadesFor(reviewTaskThatShipped);
-  assert.equal(matched.length, 0, 'a cascade-generated task never triggers another cascade');
+  assert.equal(matched.length, 0);
 });
 
-await test('the review inherits the shipped task goal and version, not goal 1000074 by fiat', () => {
-  // A copy ship in some other goal gets its review filed next to that work.
-  const { matched } = cascade.cascadesFor(shippedCopy({ goal_id: '1000046', version_id: 'BONGOS-V1' }));
-  assert.equal(matched[0].spec.goalId, 1000046);
-  assert.equal(matched[0].spec.versionId, 'BONGOS-V1');
-});
+// --- the runner still resolves its policy and the changed files --------------
 
-// --- the project's artist gate decides whether it is filed at all (ADR 0241) --
-
-await test("artist_gate 'off' files NO artist review — the one level at which the rule is silent", () => {
-  assert.equal(cascade.cascadesFor(shippedCopy(), cascade.CASCADES, { artistGate: 'off' }).matched.length, 0);
-  // The other two levels both FILE; what separates them is whether an open review
-  // holds a deploy, which is not this file's business at all.
-  assert.equal(cascade.cascadesFor(shippedCopy(), cascade.CASCADES, { artistGate: 'advisory' }).matched.length, 1);
-  assert.equal(cascade.cascadesFor(shippedCopy(), cascade.CASCADES, { artistGate: 'strict' }).matched.length, 1);
-});
-
-await test('an UNREAD policy files — silence is never read as an opt-out', () => {
-  // No context at all (an old caller), and an explicitly-undefined level (a reader
-  // that threw) must both behave like the gate's default, which is 'strict'.
-  assert.equal(cascade.cascadesFor(shippedCopy()).matched.length, 1);
-  assert.equal(cascade.cascadesFor(shippedCopy(), cascade.CASCADES, {}).matched.length, 1);
-  assert.equal(cascade.cascadesFor(shippedCopy(), cascade.CASCADES, { artistGate: undefined }).matched.length, 1);
-});
+await test('the runner still hands the artist gate to the rules, and a reader that THROWS is reported', async () => {
+  const ok = ctxProbe();
+  await cascade.runCascadesForShip({ id: '7001' }, {
+    rules: [ok.rule], getTask: async () => shippedCopy(),
+    findTaskBySourceRef: async () => null, createTask: async () => ({ id: '1' }),
+    artistGateMode: () => 'advisory',
+  });
+  assert.equal(ok.seen[0].artistGate, 'advisory');
 
-await test('a gate reader that THROWS costs the run nothing — it is reported, and the review is still filed', async () => {
   const created = [];
   const report = await cascade.runCascadesForShip({ id: '7001' }, {
     getTask: async () => shippedCopy(),
@@ -312,24 +295,11 @@ await test('a gate reader that THROWS costs the run nothing — it is reported,
     createTask: async (spec) => { created.push(spec); return { id: '7002' }; },
     artistGateMode: () => { throw new Error('pack unreadable'); },
   });
-  assert.equal(created.length, 1, 'an unreadable policy must not silently behave like off');
-  assert.ok(report.errors.some((e) => /artistGateMode\(\) threw/.test(e)), 'and it says so');
-});
-
-await test("runCascadesForShip honours 'off' end to end — nothing is created, nothing errors", async () => {
-  let creates = 0;
-  const report = await cascade.runCascadesForShip({ id: '7001' }, {
-    getTask: async () => shippedCopy(),
-    findTaskBySourceRef: async () => null,
-    createTask: async () => { creates++; return { id: '7002' }; },
-    artistGateMode: () => 'off',
-  });
-  assert.equal(creates, 0);
-  assert.deepEqual(report.created, []);
-  assert.deepEqual(report.errors, [], 'a project that switched the gate off has no problem to report');
+  assert.equal(created.length, 0, 'and the production table files nothing either way');
+  assert.ok(report.errors.some((e) => /artistGateMode\(\) threw/.test(e)), 'the failed read says so');
 });
 
-// --- the review keys on the FILES a ship changed, not its label (task 1004201) --
+// --- the changed files (task 1004201) ----------------------------------------
 
 await test('a page file changed under modules/*/public/ is visual work whatever the label says', () => {
   const H = cascade.hasCopyOrVisualWork;
@@ -358,67 +328,43 @@ await test('a backend file in a UI module is NOT visual work — page files only
   assert.equal(H(unlabelled, null), false);
 });
 
-await test('the ship runner resolves the changed files ONCE and the artist review files on them', async () => {
-  const created = [];
+await test('the ship runner resolves the changed files ONCE into ctx, and a page change files nothing', async () => {
+  const probe = ctxProbe();
   let asked = 0;
-  const deps = {
-    getTask: async () => shippedCopy({ module_key: null, discipline: 'engineer' }),
-    findTaskBySourceRef: async () => null,
-    createTask: async (spec) => { created.push(spec); return { id: String(9300 + created.length) }; },
-    changedFiles: async () => { asked++; return { paths: ['modules/hall-ui/public/goal-forest-render.js'], truncated: false }; },
-  };
-  const report = await cascade.runCascadesForShip({ id: '7001' }, deps);
+  const changedFiles = async () => { asked++; return { paths: ['modules/hall-ui/public/goal-forest-render.js'], truncated: true }; };
+  await cascade.runCascadesForShip({ id: '7001' }, {
+    rules: [probe.rule], getTask: async () => shippedCopy({ module_key: null }),
+    findTaskBySourceRef: async () => null, createTask: async () => ({ id: '1' }), changedFiles,
+  });
   assert.equal(asked, 1);
-  assert.equal(created.filter((s) => s.discipline === 'artist').length, 1, 'the unlabelled UI ship gets its review');
-  assert.deepEqual(report.errors, []);
-});
-
-await test('a changed-files list cut off at the read cap FILES the review — a padded PR cannot skip it', async () => {
-  const run = async (changed) => {
-    const created = [];
-    await cascade.runCascadesForShip({ id: '7001' }, {
-      getTask: async () => shippedCopy({ module_key: null, discipline: 'engineer' }),
-      findTaskBySourceRef: async () => null,
-      createTask: async (spec) => { created.push(spec); return { id: '9500' }; },
-      changedFiles: async () => changed,
-    });
-    return created.filter((s) => s.discipline === 'artist').length;
-  };
-  const padding = Array.from({ length: 300 }, (_, i) => `docs/pad-${i}.md`);
-  assert.equal(await run({ paths: padding, truncated: true }), 1);
-  assert.equal(await run({ paths: padding, truncated: false }), 0, 'the same list, complete, is not UI work');
-});
+  assert.deepEqual(probe.seen[0].changedFiles, ['modules/hall-ui/public/goal-forest-render.js']);
+  assert.equal(probe.seen[0].changedFilesTruncated, true);
 
-await test('a filed review is one the deploy gate HOLDS on — the rule and the gate agree on its identity', async () => {
+  // The production table, on the same ship: no artist review, nothing the
+  // deploy gate would hold, no error.
   const gate = require_(path.join(HERE, '..', '..', '..', 'src', 'bongos', 'artist-gate.js'));
   const created = [];
-  await cascade.runCascadesForShip({ id: '7001' }, {
-    getTask: async () => shippedCopy({ module_key: null, discipline: 'engineer' }),
+  const report = await cascade.runCascadesForShip({ id: '7001' }, {
+    getTask: async () => shippedCopy({ module_key: null }),
     findTaskBySourceRef: async () => null,
     createTask: async (spec) => { created.push(spec); return { id: '9600' }; },
-    changedFiles: async () => ({ paths: ['modules/public-landing/public/projects.html'], truncated: false }),
+    changedFiles, artistGateMode: () => 'strict',
   });
-  const review = created.find((s) => s.discipline === 'artist');
-  assert.ok(review, 'the review was filed');
-  assert.equal(gate.isArtistReview({ source: review.source, source_ref: review.sourceRef }), true);
+  assert.deepEqual(created, []);
+  assert.equal(created.some((s) => gate.isArtistReview({ source: s.source, source_ref: s.sourceRef })), false);
+  assert.deepEqual(report.errors, []);
 });
 
-await test('a changed-files read that fails is REPORTED, never thrown — the label match still stands', async () => {
-  const run = async (task) => {
-    const created = [];
-    const report = await cascade.runCascadesForShip({ id: '7001' }, {
-      getTask: async () => task,
-      findTaskBySourceRef: async () => null,
-      createTask: async (spec) => { created.push(spec); return { id: '9400' }; },
-      changedFiles: async () => { throw new Error('github down'); },
-    });
-    return { created, report };
-  };
-  const unlabelled = await run(shippedCopy({ module_key: null, discipline: 'engineer' }));
-  assert.equal(unlabelled.created.length, 0);
-  assert.match(unlabelled.report.errors.join('\n'), /changedFiles\(\) threw \(github down\)/);
-  const labelled = await run(shippedCopy({ module_key: 'hall-ui' }));
-  assert.equal(labelled.created.filter((s) => s.discipline === 'artist').length, 1, 'an outage never costs a labelled review');
+await test('a changed-files read that fails is REPORTED, never thrown', async () => {
+  const created = [];
+  const report = await cascade.runCascadesForShip({ id: '7001' }, {
+    getTask: async () => shippedCopy(),
+    findTaskBySourceRef: async () => null,
+    createTask: async (spec) => { created.push(spec); return { id: '9400' }; },
+    changedFiles: async () => { throw new Error('github down'); },
+  });
+  assert.equal(created.length, 0);
+  assert.match(report.errors.join('\n'), /changedFiles\(\) threw \(github down\)/);
 });
 
 const shipFiles = require_(path.join(HERE, '..', 'ship-files.js'));

package/package-lock.json

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

package/package.json

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

@@ -7697,5 +7697,11 @@
       "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"
     }
+  ],
+  "1.19.1067": [
+    {
+      "id": "1004325",
+      "text": "A ship that changes a page's words no longer files an \"Artist review\" task. Those reviews came one per ship, and most were thrown away unread. Instead, the page itself shows \"changed since last tweak\" in Tweak Mode, worked out"
+    }
   ]
 }

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