@bongos/core 1.19.1065 → 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.1065",
+  "version": "1.19.1067",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.1065",
+      "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.1065",
+  "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

@@ -7691,5 +7691,17 @@
       "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"
+    }
+  ],
+  "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.1065'; // 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');