@bongos/core 1.19.920 → 1.19.922

package/tests/idea_brightness.mjs

@@ -0,0 +1,550 @@
+// tests/idea_brightness.mjs
+//
+// task 1004099 (BV2.R16, goal 1000095) — BRIGHTNESS: the live share of an
+// idea's descent. Spec docs/specs/bongos-v2-ideator-surface.md decisions 4 and
+// 20; ADR 0313 (a removal is proposed, then confirmed by a person) and ADR 0319
+// (the verdict is a row beside the question).
+//
+// WHAT CAN GO SILENTLY WRONG HERE, which is what this file is aimed at:
+//
+//   * ZERO OVER ZERO DRAWN AS DARK. An idea that caused nothing has had nothing
+//     removed, so it is LIT. Return 0 for it and a freshly-filed thought becomes
+//     pixel-identical to one whose version the project tore out — which is
+//     precisely the distinction BV2.R19's proof exists to check, and the reason
+//     size and brightness are two channels at all. §2 pins both ends of it.
+//   * WEIGHTING BY COUNT. Three-of-five tasks alive is not 0.6 brightness unless
+//     the five hops earned the same. Counting rows makes deleting a one-line fix
+//     dim a star as hard as deleting the feature — nothing errors, the sky is
+//     just wrong. §3.
+//   * THE SHARE TAKEN OF THE WRONG WHOLE. Brightness divides by the same
+//     `credits` size draws, so `byTask` must SUM to it. It is assembled from two
+//     places (the priced descent, plus ledger payments for tasks the descent no
+//     longer reaches), and dropping the second overstates brightness silently.
+//     §4 pins the sum itself, which is the invariant the rest rests on.
+//   * A DISMISSED PROPOSAL DIMMING. Refactors, renames and moves all look like
+//     deletions to a diff — ADR 0313's central finding. Only 'confirmed' may
+//     reach the read, and the join is where that is enforced. §5.
+//   * "COULD NOT LOOK" RENDERED AS "NOTHING WAS REMOVED". With the lifecycle
+//     module off there are no removal facts, and returning a confident 1 draws
+//     every torn-out thought at full brightness. §6.
+//   * THE WRONG DIRECTION. lifecycle_009 holds `ship_task_id` — the task that
+//     DID the deleting — and brightness needs the tasks that WERE deleted. They
+//     are different rows under different ideas. §7 pins that the read is keyed
+//     on removed_task_id.
+//   * A SECOND DERIVATION ERASING A GOOD FIRST ONE. The commit-history walk is
+//     capped and rate-limited, so a re-ship can legitimately find fewer paths.
+//     ON CONFLICT DO NOTHING, never DO UPDATE. §8.
+//   * THE ATTRIBUTION NEVER BEING STORED AT ALL. The writer is wired into the
+//     cascade through a dep, and this module's own history says a closure there
+//     is unreachable from a test and is how a dead rule passed its suite. §9
+//     drives the real runner.
+//
+// DB-free: the clients are stubs. Where a stub stands in for SQL, it reads the
+// STATEMENT rather than reimplementing it from memory, so a change to the query
+// moves the twin with it instead of leaving it agreeing with a stale copy.
+//
+// Run:  node tests/idea_brightness.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const api = require('../src/module-api.js');
+const credits = require('../modules/economy/credits.js');
+const brightnessLib = require('../modules/economy/idea-brightness.js');
+const removalTargets = require('../modules/lifecycle/removal-targets.js');
+const cascade = require('../modules/lifecycle/cascade.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed += 1; console.log(`ok   ${name}`); }
+  catch (err) { failed += 1; console.log(`FAIL ${name}\n     ${err && (err.message || JSON.stringify(err))}`); }
+}
+
+const PREFIX = credits.IDEA_STREAM_REASON_PREFIXES.task_ship;
+
+// ---------------------------------------------------------------------------
+// the stubs
+// ---------------------------------------------------------------------------
+
+// A client standing in for the two reads ideaSizes makes: the credit_log
+// rollup, and the grades lookup. Faithful to the statement on the one point
+// that matters here — it groups per (idea, task), which is where `byTask` comes
+// from.
+function sizeClient({ ledger = [], grades = [] } = {}) {
+  return {
+    async query(sql, params) {
+      if (/FROM credit_log/i.test(sql)) {
+        const field = /split_part\(reason, ':', (\d+)\)/.exec(sql);
+        assert.ok(field, 'the read must take the idea id off the separator');
+        const idx = Number(field[1]) - 1;
+        const guard = /reason LIKE '([^']*)%'/.exec(sql);
+        const prefix = guard && guard[1].replace(/\\([\\%_])/g, (m, ch) => ch);
+        const ids = (params[0] || []).map(String);
+        const grouped = new Map();
+        for (const row of ledger) {
+          if (prefix && !String(row.reason).startsWith(prefix)) continue;
+          const parts = String(row.reason).split(':');
+          const ideaId = parts[idx];
+          if (!ids.includes(ideaId)) continue;
+          const taskId = row.task_id != null ? String(row.task_id) : parts[2];
+          const key = `${ideaId}|${taskId}`;
+          const acc = grouped.get(key) || { idea_id: ideaId, task_id: taskId, credits: 0, payments: 0 };
+          acc.credits += Number(row.delta);
+          acc.payments += 1;
+          grouped.set(key, acc);
+        }
+        return { rows: [...grouped.values()] };
+      }
+      if (/FROM idea_inbox/i.test(sql)) return { rows: grades };
+      return { rows: [] };
+    },
+  };
+}
+
+// A twin of the confirmedRemovalsForTasks join, driven off fixture rows. It
+// reads the verdict filter out of the SQL rather than hardcoding it, so
+// loosening the join to include dismissals reds §5 instead of passing.
+function removalsClient({ targets = [], verdicts = [] } = {}) {
+  const log = [];
+  return {
+    log,
+    async query(sql, params) {
+      log.push({ sql, params });
+      if (/lifecycle_removal_targets/i.test(sql) && /lifecycle_removal_verdicts/i.test(sql)) {
+        const want = /v\.verdict\s*=\s*'([a-z]+)'/.exec(sql);
+        assert.ok(want, 'the join must filter on a literal verdict — a read that takes every answer dims on dismissals');
+        const asked = (params[0] || []).map(String);
+        // The keyed column is read out of the statement too: keying on
+        // ship_task_id would dim the ship's own idea instead of the one whose
+        // work died, and it would still look like a working query.
+        assert.ok(/tg\.removed_task_id = ANY/.test(sql),
+          'the set must be matched on removed_task_id — ship_task_id is the task that DID the deleting');
+        const byProposal = new Map(verdicts.map((v) => [String(v.proposal_task_id), v]));
+        const rows = [];
+        for (const t of targets) {
+          const v = byProposal.get(String(t.proposal_task_id));
+          if (!v || v.verdict !== want[1]) continue;
+          if (!asked.includes(String(t.removed_task_id))) continue;
+          rows.push({
+            removed_task_id: t.removed_task_id,
+            proposal_task_id: t.proposal_task_id,
+            paths: t.paths || [],
+            ship_task_id: v.ship_task_id ?? null,
+            decided_at: v.decided_at || null,
+          });
+        }
+        rows.sort((a, b) => String(a.removed_task_id).localeCompare(String(b.removed_task_id))
+          || String(a.decided_at).localeCompare(String(b.decided_at))
+          || String(a.proposal_task_id).localeCompare(String(b.proposal_task_id)));
+        return { rows };
+      }
+      return { rows: [] };
+    },
+  };
+}
+
+// The port, registered ONCE. registerProvider throws on a duplicate (a port is
+// single-provider), and the client the port closes over is swapped per test so
+// each case reads its own fixture.
+let portClient = removalsClient();
+if (!api.hasProvider('lifecycle.removals')) {
+  api.registerProvider('lifecycle.removals', {
+    confirmedRemovalsForTasks: (ids) => removalTargets.confirmedRemovalsForTasks(ids, { client: portClient }),
+    countUnattributedConfirmed: () => removalTargets.countUnattributedConfirmed({ client: portClient }),
+  });
+}
+
+// One idea, `descent` hops, each paid `perTask` credits under stream 1.
+function ledgerFor(ideaId, perTask) {
+  return Object.entries(perTask).map(([taskId, delta]) => ({
+    reason: `${PREFIX}${ideaId}:${taskId}`, task_id: taskId, delta,
+  }));
+}
+function descentFor(ideaId, taskIds) {
+  return new Map([[String(ideaId), taskIds.map((t, i) => ({ task_id: String(t), depth: i === 0 ? 0 : 1, status: 'shipped' }))]]);
+}
+
+async function brightnessOf(ideaId, { perTask, targets = [], verdicts = [], grades = null } = {}) {
+  portClient = removalsClient({ targets, verdicts });
+  const client = sizeClient({
+    ledger: ledgerFor(ideaId, perTask),
+    grades: grades || [{ id: Number(ideaId), grade: 'quick', completeness: null }],
+  });
+  const all = await brightnessLib.ideaBrightnesses([String(ideaId)], {
+    client,
+    descentByIdea: descentFor(ideaId, Object.keys(perTask)),
+  });
+  return all.get(String(ideaId));
+}
+
+// ---------------------------------------------------------------------------
+// §1 — graded, not binary (spec decision 20)
+// ---------------------------------------------------------------------------
+
+await test('§1 a descent with some work removed is PARTLY lit — not on, not off', async () => {
+  const b = await brightnessOf(7, {
+    perTask: { 100: 10, 101: 10, 102: 10, 103: 10, 104: 10 },
+    targets: [{ proposal_task_id: 900, removed_task_id: 101, paths: ['a.js'] },
+              { proposal_task_id: 900, removed_task_id: 102, paths: ['b.js'] }],
+    verdicts: [{ proposal_task_id: 900, verdict: 'confirmed', ship_task_id: 555, decided_at: '2026-09-01' }],
+  });
+  assert.equal(b.credits, 50);
+  assert.equal(b.removed, 20);
+  assert.equal(b.live, 30);
+  assert.equal(b.share, 0.6, 'three of five equal hops alive is 0.6, not 0 and not 1');
+  assert.ok(b.share > 0 && b.share < 1, 'graded means strictly between the ends');
+});
+
+await test('§1 a star goes out only when NOTHING survives', async () => {
+  const b = await brightnessOf(8, {
+    perTask: { 200: 25, 201: 25 },
+    targets: [{ proposal_task_id: 901, removed_task_id: 200, paths: [] },
+              { proposal_task_id: 901, removed_task_id: 201, paths: [] }],
+    verdicts: [{ proposal_task_id: 901, verdict: 'confirmed', ship_task_id: 556, decided_at: '2026-09-02' }],
+  });
+  assert.equal(b.share, 0);
+  assert.equal(b.live, 0);
+});
+
+// ---------------------------------------------------------------------------
+// §2 — LARGE AND DEAD vs NEVER MATTERED (the BV2.R19 distinction)
+// ---------------------------------------------------------------------------
+//
+// The two states one number cannot express, and the reason brightness exists
+// beside size rather than replacing it.
+
+await test('§2 a large dead thought keeps FULL size and reaches zero brightness', async () => {
+  const b = await brightnessOf(9, {
+    perTask: { 300: 200, 301: 150 },
+    targets: [{ proposal_task_id: 902, removed_task_id: 300, paths: [] },
+              { proposal_task_id: 902, removed_task_id: 301, paths: [] }],
+    verdicts: [{ proposal_task_id: 902, verdict: 'confirmed', ship_task_id: 557, decided_at: '2026-09-03' }],
+  });
+  assert.equal(b.credits, 350, 'size does not fall — ADR 0313, the ledger is never rewritten');
+  assert.equal(b.share, 0);
+  assert.equal(b.hasWork, true, 'it DID cause work; that is what makes it large');
+});
+
+await test('§2 a thought that never caused anything is LIT, not dark — zero over zero is not zero', async () => {
+  const b = await brightnessOf(10, { perTask: {} });
+  assert.equal(b.credits, 0);
+  assert.equal(b.share, 1, 'nothing has been removed from it; a protostar is not a remnant');
+  assert.equal(b.hasWork, false, 'and this is what lets BV2.R17 tell it from a lit star that earned its light');
+});
+
+await test('§2 the two are distinguishable on the pair, which is the whole point', async () => {
+  const dead = await brightnessOf(11, {
+    perTask: { 400: 120 },
+    targets: [{ proposal_task_id: 903, removed_task_id: 400, paths: [] }],
+    verdicts: [{ proposal_task_id: 903, verdict: 'confirmed', ship_task_id: 558, decided_at: '2026-09-04' }],
+  });
+  const never = await brightnessOf(12, { perTask: {} });
+  assert.notEqual(`${dead.credits}|${dead.share}`, `${never.credits}|${never.share}`,
+    'a large dead thought and one that never mattered must not render alike');
+  assert.ok(dead.credits > never.credits, 'size separates them');
+  assert.ok(dead.share < never.share, 'and brightness separates them the other way');
+});
+
+// ---------------------------------------------------------------------------
+// §3 — weighted by PAYOUT, not by count
+// ---------------------------------------------------------------------------
+
+await test('§3 removing a small hop dims less than removing a large one', async () => {
+  const small = await brightnessOf(13, {
+    perTask: { 500: 90, 501: 10 },
+    targets: [{ proposal_task_id: 904, removed_task_id: 501, paths: [] }],
+    verdicts: [{ proposal_task_id: 904, verdict: 'confirmed', ship_task_id: 559, decided_at: '2026-09-05' }],
+  });
+  const large = await brightnessOf(14, {
+    perTask: { 600: 90, 601: 10 },
+    targets: [{ proposal_task_id: 905, removed_task_id: 600, paths: [] }],
+    verdicts: [{ proposal_task_id: 905, verdict: 'confirmed', ship_task_id: 560, decided_at: '2026-09-06' }],
+  });
+  assert.equal(small.share, 0.9);
+  assert.equal(large.share, 0.1);
+  assert.ok(small.share > large.share,
+    'one task of two removed either way — a count-weighted brightness would make these equal');
+});
+
+await test('§3 what went out is reported, largest loss first', async () => {
+  const b = await brightnessOf(15, {
+    perTask: { 700: 5, 701: 50 },
+    targets: [{ proposal_task_id: 906, removed_task_id: 700, paths: ['small.js'] },
+              { proposal_task_id: 906, removed_task_id: 701, paths: ['big.js'] }],
+    verdicts: [{ proposal_task_id: 906, verdict: 'confirmed', ship_task_id: 561, decided_at: '2026-09-07' }],
+  });
+  assert.deepEqual(b.removedTasks.map((r) => r.taskId), ['701', '700'],
+    'a surface explaining why a star dimmed wants the piece that mattered first');
+  assert.deepEqual(b.removedTasks[0].paths, ['big.js'], 'the receipt travels with it');
+  assert.equal(b.removedTasks[0].proposalTaskId, '906', 'and so does the question that was answered');
+});
+
+// ---------------------------------------------------------------------------
+// §4 — the share is taken of the SAME whole size draws
+// ---------------------------------------------------------------------------
+
+await test('§4 byTask SUMS to credits — the invariant every share above rests on', async () => {
+  const ideaSizeLib = require('../modules/economy/idea-size.js');
+  const client = sizeClient({
+    ledger: ledgerFor(21, { 800: 7, 801: 13 }),
+    grades: [{ id: 21, grade: 'quick', completeness: null }],
+  });
+  const sizes = await ideaSizeLib.ideaSizes(['21'], { client, descentByIdea: descentFor(21, [800, 801]) });
+  const s = sizes.get('21');
+  const summed = [...s.byTask.values()].reduce((a, b) => a + b, 0);
+  assert.equal(summed, s.credits, 'a breakdown that does not sum to the whole makes every brightness a fraction of the wrong number');
+});
+
+await test('§4 a payout for a task the descent no longer reaches stays LIVE, not lost', async () => {
+  // The ledger paid task 900 under this idea, but the descent walk does not
+  // reach it any more (a re-parented task, a deleted edge). idea-size.js keeps
+  // it in `credits` on purpose so size cannot fall; brightness must keep it in
+  // `live` for the same reason, or a re-parenting would dim a star.
+  portClient = removalsClient();
+  const client = sizeClient({
+    ledger: ledgerFor(22, { 850: 10, 900: 40 }),
+    grades: [{ id: 22, grade: 'quick', completeness: null }],
+  });
+  const all = await brightnessLib.ideaBrightnesses(['22'], {
+    client,
+    descentByIdea: descentFor(22, [850]),   // 900 is absent from the descent
+  });
+  const b = all.get('22');
+  assert.equal(b.credits, 50, 'the orphan payout is still money this idea was paid');
+  assert.equal(b.removed, 0);
+  assert.equal(b.live, 50, 'and it is alive — nothing said otherwise');
+  assert.equal(b.share, 1);
+});
+
+await test('§4 an orphan payout whose work IS confirmed removed still dims the star', async () => {
+  // The case that makes the byTask merge load-bearing, and the one the test
+  // above cannot see. `live = credits - removed` means an orphan the descent
+  // misses is counted as alive whether or not the merge exists — so only a
+  // REMOVED orphan can tell the two implementations apart. Drop the merge in
+  // idea-size.js and task 900 is absent from byTask, nothing matches the
+  // confirmed removal, and the idea reads fully lit while the work is gone.
+  portClient = removalsClient({
+    targets: [{ proposal_task_id: 920, removed_task_id: 900, paths: ['orphan.js'] }],
+    verdicts: [{ proposal_task_id: 920, verdict: 'confirmed', ship_task_id: 580, decided_at: '2026-09-11' }],
+  });
+  const client = sizeClient({
+    ledger: ledgerFor(23, { 850: 10, 900: 40 }),
+    grades: [{ id: 23, grade: 'quick', completeness: null }],
+  });
+  const all = await brightnessLib.ideaBrightnesses(['23'], {
+    client,
+    descentByIdea: descentFor(23, [850]),   // 900 is paid but off the descent
+  });
+  const b = all.get('23');
+  assert.equal(b.credits, 50, 'size still counts it — the money moved');
+  assert.equal(b.removed, 40, 'and brightness must see it die');
+  assert.equal(b.share, 0.2);
+  assert.deepEqual(b.removedTasks.map((r) => r.taskId), ['900']);
+});
+
+// ---------------------------------------------------------------------------
+// §5 — only a CONFIRMED removal dims (ADR 0313)
+// ---------------------------------------------------------------------------
+
+await test('§5 a DISMISSED proposal dims nothing — a refactor is not a removal', async () => {
+  const b = await brightnessOf(16, {
+    perTask: { 750: 30, 751: 30 },
+    targets: [{ proposal_task_id: 907, removed_task_id: 750, paths: ['moved.js'] }],
+    verdicts: [{ proposal_task_id: 907, verdict: 'dismissed', ship_task_id: 562, decided_at: '2026-09-08' }],
+  });
+  assert.equal(b.share, 1);
+  assert.equal(b.removed, 0);
+  assert.deepEqual(b.removedTasks, []);
+});
+
+await test('§5 an UNANSWERED proposal dims nothing — the question is not the verdict', async () => {
+  const b = await brightnessOf(17, {
+    perTask: { 760: 30, 761: 30 },
+    targets: [{ proposal_task_id: 908, removed_task_id: 760, paths: [] }],
+    verdicts: [],   // filed, nobody has answered it
+  });
+  assert.equal(b.share, 1, 'a derived-only signal would dim the sky continuously — ADR 0313');
+});
+
+// ---------------------------------------------------------------------------
+// §6 — "could not look" is not "nothing was removed"
+// ---------------------------------------------------------------------------
+
+await test('§6 with no removal port the share is NULL and says so, never a confident 1', async () => {
+  // Resolve the port away by asking for a name nothing registers. The module
+  // resolves OPTIONALLY, so this is the lifecycle-module-is-off path.
+  const mod = require('../modules/economy/idea-brightness.js');
+  const src = fs.readFileSync(path.join(ROOT, 'modules/economy/idea-brightness.js'), 'utf8');
+  assert.ok(/resolveOptional\(['"]lifecycle\.removals['"]\)/.test(src),
+    'the port must be resolved OPTIONALLY — a required resolve throws and takes the whole read down with the module');
+  assert.ok(/attributable: false/.test(src) && /share: null/.test(src),
+    'and the unreadable case must report itself rather than defaulting to lit');
+  assert.ok(typeof mod.ideaBrightnesses === 'function');
+});
+
+// ---------------------------------------------------------------------------
+// §7 — the direction of the read
+// ---------------------------------------------------------------------------
+
+await test('§7 a task named by TWO confirmed proposals collapses to the earliest', async () => {
+  const client = removalsClient({
+    targets: [{ proposal_task_id: 910, removed_task_id: 770, paths: ['first.js'] },
+              { proposal_task_id: 911, removed_task_id: 770, paths: ['second.js'] }],
+    verdicts: [{ proposal_task_id: 911, verdict: 'confirmed', ship_task_id: 571, decided_at: '2026-09-20' },
+               { proposal_task_id: 910, verdict: 'confirmed', ship_task_id: 570, decided_at: '2026-09-10' }],
+  });
+  const got = await removalTargets.confirmedRemovalsForTasks(['770'], { client });
+  assert.equal(got.size, 1, 'the question is binary — how many times it died is not the fact');
+  assert.equal(got.get('770').proposalTaskId, '910', 'the earliest verdict is the one kept');
+  assert.deepEqual(got.get('770').paths, ['first.js']);
+});
+
+await test('§7 the SQL keys on removed_task_id, not on the ship that did the deleting', async () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/removal-targets.js'), 'utf8');
+  const stmt = /FROM lifecycle_removal_targets tg[\s\S]*?ORDER BY/.exec(src);
+  assert.ok(stmt, 'the join must be findable');
+  assert.ok(/tg\.removed_task_id = ANY/.test(stmt[0]),
+    'brightness asks which tasks WERE removed; ship_task_id is the one that did the removing, under a different idea');
+  assert.ok(/v\.verdict = 'confirmed'/.test(stmt[0]), 'and only a confirmed answer may reach it');
+});
+
+// ---------------------------------------------------------------------------
+// §8 — the writer
+// ---------------------------------------------------------------------------
+
+function captureClient() {
+  const calls = [];
+  return { calls, async query(sql, params) { calls.push({ sql, params }); return { rowCount: 1, rows: [] }; } };
+}
+
+await test('§8 the writer sends ONE jsonb payload — a text[][] would flatten and mispair', async () => {
+  const c = captureClient();
+  await removalTargets.recordRemovalTargets(
+    { proposalTaskId: 1000, removals: [{ taskId: 11, paths: ['a.js', 'b.js'] }, { taskId: 12, paths: ['c.js'] }] },
+    { client: c }
+  );
+  assert.equal(c.calls.length, 1, 'one statement, one round trip');
+  const { sql, params } = c.calls[0];
+  assert.ok(/jsonb_array_elements/.test(sql), 'nested paths need jsonb; unnest on text[][] flattens completely');
+  assert.ok(!/unnest\(\$\d+::text\[\]\[\]\)/.test(sql), 'the flattening shape must not come back');
+  const payload = JSON.parse(params[1]);
+  assert.deepEqual(payload, [{ taskId: '11', paths: ['a.js', 'b.js'] }, { taskId: '12', paths: ['c.js'] }],
+    'each task keeps its OWN paths — the bug a flattened array causes is silent mispairing');
+});
+
+await test('§8 a re-run cannot erase a better first attribution — DO NOTHING, never DO UPDATE', async () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/removal-targets.js'), 'utf8');
+  // Scoped to the STATEMENT, not the file. The header explains at length why
+  // there is no DO UPDATE, so a file-wide scan for that string matches the
+  // prose arguing against it and fails on a correct implementation — the same
+  // trap §7 avoids by slicing the query out first.
+  const stmt = /INSERT INTO lifecycle_removal_targets[\s\S]*?DO NOTHING`/.exec(src);
+  assert.ok(stmt, 'the insert must be findable');
+  assert.ok(/ON CONFLICT \(proposal_task_id, removed_task_id\) DO NOTHING/.test(stmt[0]));
+  assert.ok(!/DO UPDATE/.test(stmt[0]),
+    'a capped, rate-limited second walk can find FEWER paths; overwriting would let it erase a good first read');
+});
+
+await test('§8 two entries for one task MERGE their paths rather than dropping half the receipt', async () => {
+  const c = captureClient();
+  await removalTargets.recordRemovalTargets(
+    { proposalTaskId: 1001, removals: [{ taskId: 20, paths: ['x.js'] }, { taskId: 20, paths: ['y.js'] }] },
+    { client: c }
+  );
+  const payload = JSON.parse(c.calls[0].params[1]);
+  assert.equal(payload.length, 1, 'a doubled pair inside ONE insert is not something ON CONFLICT rescues');
+  assert.deepEqual(payload[0].paths.sort(), ['x.js', 'y.js']);
+});
+
+await test('§8 nothing to attribute writes nothing at all', async () => {
+  const c = captureClient();
+  assert.equal(await removalTargets.recordRemovalTargets({ proposalTaskId: 1002, removals: [] }, { client: c }), 0);
+  assert.equal(await removalTargets.recordRemovalTargets({ proposalTaskId: 1003, removals: [{ taskId: 'nope' }] }, { client: c }), 0);
+  assert.equal(await removalTargets.recordRemovalTargets({ proposalTaskId: 0, removals: [{ taskId: 5 }] }, { client: c }), 0);
+  assert.equal(c.calls.length, 0, 'an empty attribution is a real answer, not a query');
+});
+
+// ---------------------------------------------------------------------------
+// §9 — the wiring, through the REAL cascade runner
+// ---------------------------------------------------------------------------
+//
+// The dep is what makes this reachable at all, and this module's own history is
+// the argument for driving the runner rather than the writer: the removal rule
+// shipped dead in production because its resolver was a closure inside the
+// listener registration that no test could see.
+
+function cascadeDeps({ recorded, existing = null }) {
+  return {
+    getTask: async () => ({ id: '4242', source: 'idea-route', goal_id: '1', version_id: 'V', touches: [] }),
+    findTaskBySourceRef: async () => existing,
+    createTask: async (spec) => ({ id: '5555', ...spec }),
+    removalCandidates: async () => ({
+      removals: [{ taskId: '31', title: 'the removed one', paths: ['gone.js'] }],
+      truncated: false, deletedCount: 1, errors: [],
+    }),
+    recordRemovalTargets: async (args) => { recorded.push(args); return 1; },
+  };
+}
+
+await test('§9 filing a removal proposal stores its targets against the proposal task', async () => {
+  const recorded = [];
+  const report = await cascade.runCascadesForShip({ id: '4242' }, cascadeDeps({ recorded }));
+  assert.equal(report.errors.length, 0, report.errors.join(' | '));
+  assert.equal(recorded.length, 1, 'the attribution must be persisted, not only rendered into the body');
+  assert.equal(recorded[0].proposalTaskId, '5555', 'against the PROPOSAL, which is what the verdict joins on');
+  assert.deepEqual(recorded[0].removals.map((r) => r.taskId), ['31']);
+});
+
+await test('§9 a RE-SHIP still stores them — the repair path for a first run that derived nothing', async () => {
+  const recorded = [];
+  // The proposal already exists, so the runner reports it as `skipped`.
+  const report = await cascade.runCascadesForShip({ id: '4242' }, cascadeDeps({ recorded, existing: { id: '5555' } }));
+  assert.equal(report.created.length, 0);
+  assert.ok(report.skipped.some((s) => s.taskId === '5555'), 'the proposal was already filed');
+  assert.equal(recorded.length, 1, 'and the targets are written anyway — idempotent, so it costs a no-op and buys the repair');
+  assert.equal(recorded[0].proposalTaskId, '5555');
+});
+
+await test('§9 a writer that throws is REPORTED and never costs the ship', async () => {
+  const deps = cascadeDeps({ recorded: [] });
+  deps.recordRemovalTargets = async () => { throw new Error('db is down'); };
+  const report = await cascade.runCascadesForShip({ id: '4242' }, deps);
+  assert.ok(report.errors.some((e) => /recordRemovalTargets/.test(e) && /db is down/.test(e)),
+    'the failure must be named in the report');
+  assert.ok(Array.isArray(report.created), 'and the run still returns a report rather than rejecting');
+});
+
+await test('§9 no derivation means no write — an empty attribution is not an empty proposal', async () => {
+  const recorded = [];
+  const deps = cascadeDeps({ recorded });
+  deps.removalCandidates = async () => ({ removals: [], truncated: false, deletedCount: 0, errors: [] });
+  await cascade.runCascadesForShip({ id: '4242' }, deps);
+  assert.equal(recorded.length, 0);
+});
+
+// ---------------------------------------------------------------------------
+// §10 — the gap brightness cannot close, made visible instead of silent
+// ---------------------------------------------------------------------------
+
+await test('§10 confirmed removals that name no target are COUNTED, not ignored', async () => {
+  const client = {
+    async query(sql) {
+      assert.ok(/NOT EXISTS/.test(sql) && /lifecycle_removal_targets/.test(sql),
+        'the count is of confirmed verdicts with no target rows');
+      assert.ok(/v\.verdict = 'confirmed'/.test(sql));
+      return { rows: [{ n: 3 }] };
+    },
+  };
+  assert.equal(await removalTargets.countUnattributedConfirmed({ client }), 3,
+    'brightness cannot dim for these — it does not know which idea — so the honest move is to say how many it could not see');
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/no_artifact_escalation.mjs

@@ -139,9 +139,19 @@ await test('ONLY a no-artifact close is auto-escalated, never a bypass of a FAIL
   assert.match(src, /noArtifactClose = true;/,
     'and something must actually SET it, or the branch is unreachable and the guard is a lie');
   // Reachability: the assignment has to live in the allow-empty branch specifically.
-  const allowEmptyBranch = src.slice(src.indexOf("verdict.reason === 'allow-empty'"));
-  assert.ok(allowEmptyBranch.indexOf('noArtifactClose = true;') > -1
-    && allowEmptyBranch.indexOf('noArtifactClose = true;') < 1200,
+  //
+  // This used to assert the assignment appeared within 1200 characters of the branch
+  // marker. That is a proxy for "inside the branch", and task 1004011 redded it by
+  // adding a COMMENT — the invariant held, the character budget did not. A distance
+  // pin fails on prose and passes on a move of 1100 characters into the wrong block,
+  // so it is wrong in both directions. Bound it by the branch's own END instead: the
+  // next top-level step in shipMain. That is the thing the guard's reachability
+  // actually depends on.
+  const fromMarker = src.slice(src.indexOf("verdict.reason === 'allow-empty'"));
+  const branchEnd = fromMarker.indexOf('---- Module drift check');
+  assert.ok(branchEnd > -1, 'the marker that ends the allow-empty branch must still exist');
+  const allowEmptyBranch = fromMarker.slice(0, branchEnd);
+  assert.ok(allowEmptyBranch.includes('noArtifactClose = true;'),
     'noArtifactClose must be set in the allow-empty branch, not somewhere it can never run');
 });