@bongos/core 1.19.1006 → 1.19.1008

package/tests/ideator_large_dead_thought_proof.mjs

@@ -0,0 +1,399 @@
+// tests/ideator_large_dead_thought_proof.mjs
+//
+// THE PROOF for criterion `ideator-sky-tells-the-truth` (goal 1000095,
+// BONGOS-V2), written under task 1004106 (BV2.R27). Sibling of
+// tests/ideator_traceable_proof.mjs (R21), tests/ideator_fork_pays_proof.mjs
+// (R23) and tests/ideator_full_idea_shapes_space_proof.mjs (R25), and it keeps
+// their standard: a proof whose only possible outcome is "confirmed" is not a
+// proof. Every claim was probed by breaking the real code — see
+// docs/governance/bongos-v2-ideator-sky-tells-the-truth-proof.md.
+//
+// THE SINGLE SCENARIO THE CRITERION EXISTS FOR: a thought that caused
+// substantial work which the project has since removed shows at FULL SIZE and
+// ZERO BRIGHTNESS, and is distinguishable at a glance from a thought that never
+// caused anything at all. If those two render alike, the criterion is not met
+// however green the build is — that distinction is the entire reason size and
+// brightness are two channels instead of one number.
+//
+// WHAT THIS ADDS OVER tests/hall_sky.mjs, which already has a case named "A
+// LARGE DEAD THOUGHT RENDERS LARGE AND DEAD". That case is correct and stays.
+// But it builds its rows BY HAND — its `remnant()` fixture literally writes
+// `size: { credits: 180, scale: 0.86 }` beside `brightness: 0` — so it asserts
+// that a renderer handed a preserved size draws a preserved size. The claim the
+// criterion actually makes is one layer below that: **that the size IS
+// preserved**, by the server, after the removal. A brightness read that dimmed
+// the size as it dimmed the light would leave every assertion in that suite
+// green, because the suite told the fixture what the size was. That comment in
+// hall_sky.mjs says as much — the large-dead case is "the thing BV2.R27 goes on
+// to prove".
+//
+// SO THIS RUNS THE WHOLE PATH, NOT ITS MIDDLE:
+//
+//   credit_log rows ──▶ real ideaSizes ──▶ real ideaBrightnesses (real removals
+//   port) ──▶ real resolveIdeaState ──▶ the row the route emits ──▶ REAL sky.js
+//   in a vm ──▶ the geometry a reader sees
+//
+// Nothing between the ledger and the glyph is hand-written. `scale` is COMPUTED
+// from the ledger after the removal is confirmed, never asserted into place, so
+// "size never falls" is a measurement here rather than a fixture's promise.
+//
+// DB-free: pool.query is patched on the doorway and the store throws on any SQL
+// it does not recognise, so a renamed column cannot turn this green by
+// answering nothing.
+//
+// Run:  node tests/ideator_large_dead_thought_proof.mjs
+
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { makeRunner, settle, bootSkyPage } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+const { test, summary } = makeRunner();
+const drain = async (n = 20) => { for (let i = 0; i < n; i += 1) await settle(); };
+
+// ---------------------------------------------------------------------------
+// The ledger. One table, read by the real economy SQL.
+// ---------------------------------------------------------------------------
+
+// credit_log rows: { reason, task_id, delta }. `reason` carries the idea id the
+// way the real writer embeds it — `idea.credit.task_ship:<ideaId>:<taskId>`.
+let creditLog = [];
+
+function answer(sql, params) {
+  const s = sql.replace(/\s+/g, ' ').trim();
+
+  if (/FROM credit_log/i.test(s) && /split_part\(reason, ':', 2\)/i.test(s)) {
+    const wanted = new Set((params[0] || []).map(String));
+    // GROUP BY (idea_id, task_id), exactly as the real read does.
+    const groups = new Map();
+    for (const row of creditLog) {
+      const parts = String(row.reason).split(':');
+      // The stream-1 prefix filter. A stream-2 row (`idea.credit.full_pass:…`)
+      // is the thought, not the work it caused, and must not be summed here.
+      if (!String(row.reason).startsWith('idea.credit.task_ship:')) continue;
+      const ideaId = parts[1];
+      if (!wanted.has(String(ideaId))) continue;
+      const key = `${ideaId}\u0000${row.task_id}`;
+      const acc = groups.get(key) || { idea_id: ideaId, task_id: row.task_id, credits: 0, payments: 0 };
+      acc.credits += Number(row.delta) || 0;
+      acc.payments += 1;
+      groups.set(key, acc);
+    }
+    return { rows: [...groups.values()] };
+  }
+
+  // The grade read the size path makes: an idea's grade is what prices the
+  // hops the ledger never paid for. Every idea here is graded `quick` and has
+  // an empty descent, so nothing is estimated — but the read still happens and
+  // the store still has to answer it honestly.
+  if (/FROM idea_inbox i LEFT JOIN ideas_grades g/i.test(s)) {
+    return { rows: (params[0] || []).map((id) => ({ id: String(id), grade: 'quick', completeness: null })) };
+  }
+
+  throw new Error(`the store does not recognise this SQL — a hop moved:\n  ${s.slice(0, 200)}`);
+}
+
+api.pool.query = async (sql, params = []) => answer(sql, params);
+
+// ---------------------------------------------------------------------------
+// The ports. `lifecycle.removals` is the one the whole criterion turns on: a
+// removal is a PERSON'S confirmed verdict (ADR 0313), never a diff.
+// ---------------------------------------------------------------------------
+
+// taskId -> { proposalTaskId, paths }. Reassigned per case.
+let removals = new Map();
+
+const removalsPort = {
+  confirmedRemovalsForTasks: async (taskIds) => {
+    const out = new Map();
+    for (const id of taskIds) {
+      const hit = removals.get(String(id));
+      if (hit) out.set(String(id), hit);
+    }
+    return out;
+  },
+};
+
+if (!api.hasProvider('lifecycle.removals')) api.registerProvider('lifecycle.removals', removalsPort);
+// The descent walk. These ideas' payouts are all direct roots, which is the live
+// shape (see the record: no multi-hop descent exists on this instance), so the
+// walk has nothing to add and an empty descent is the honest answer.
+if (!api.hasProvider('ideas.descent')) {
+  api.registerProvider('ideas.descent', { descentForIdeas: async () => new Map() });
+}
+
+const economy = require('../modules/economy/idea-size.js');
+const { compressIdeaSize } = economy;
+const { ideaBrightnesses } = require('../modules/economy/idea-brightness.js');
+const { attachStateToTrail } = require('../modules/ideas/idea-state.js');
+const { attachSizeToTrail } = require('../modules/ideas/trail-size.js');
+
+// The `reward` port, carrying the REAL economy functions. Both attachers reach
+// economy only through this door (ADR 0083), so registering the real ones is
+// what makes the two hops below run production code rather than a stand-in.
+if (!api.hasProvider('reward')) {
+  api.registerProvider('reward', {
+    ideaSizes: economy.ideaSizes,
+    ideaBrightnesses,
+    // An idea whose payouts are all direct roots has no descent rows to price.
+    descentRowsFromTrail: () => [],
+  });
+}
+
+// ---------------------------------------------------------------------------
+// THE SERVER HALF, assembled by real code only. This is what the route emits.
+// ---------------------------------------------------------------------------
+
+// Build the trail rows for a cast of ideas, running every server hop for real.
+async function trailRowsFor(cast) {
+  // The rows as the trail read builds them BEFORE size and state exist. Every
+  // field below is an ordinary idea_inbox fact; `size` and `state` are left off
+  // entirely, because the whole point is that the server puts them there.
+  const rows = cast.map((c) => ({
+      id: c.id,
+      title: c.title,
+      kind: 'feature',
+      status: c.status,
+      captured_at: '2026-09-01T00:00:00.000Z',
+      triage_note: null,
+      promoted_to_task_id: null,
+      promoted_task_title: null,
+      promoted_task_status: null,
+      merged_into_idea_id: null,
+      merged_into_idea_title: null,
+      lineage_tasks: [],
+      descent_tasks: [],
+  }));
+
+  // THE TWO REAL HOPS, in the order the route composes them: size first (state
+  // reuses the byTask breakdown size computed), then state.
+  await attachSizeToTrail(rows);
+  await attachStateToTrail(rows);
+  return rows;
+}
+
+const page = (ideas) => ({ ideas, total: ideas.length, offset: 0, limit: 100 });
+
+// Read a glyph's geometry back off the markup the real renderer wrote.
+function glyphOf(html, ideaId) {
+  const re = new RegExp(`data-idea="${ideaId}"[\\s\\S]*?<span class="sky-glyph"([^>]*)>`);
+  const m = re.exec(html);
+  if (!m) return null;
+  const attrs = m[1];
+  return {
+    object: (/data-object="([^"]+)"/.exec(attrs) || [])[1] || null,
+    d: Number((/--d:(\d+)px/.exec(attrs) || [])[1]),
+    lit: Number((/--lit:([\d.]+)/.exec(attrs) || [])[1]),
+    unknownSize: /data-size="unknown"/.test(attrs),
+  };
+}
+const labelOf = (html, ideaId) =>
+  (new RegExp(`data-idea="${ideaId}"[\\s\\S]*?aria-label="([^"]*)"`).exec(html) || [])[1] || '';
+
+// Render a cast end to end and hand back the glyphs, so a case states the
+// SCENARIO and never the plumbing.
+async function render(cast) {
+  const rows = await trailRowsFor(cast);
+  const p = bootSkyPage({ pages: [page(rows)] });
+  await drain();
+  const html = p.field();
+  return { html, rows, glyph: (id) => glyphOf(html, id), label: (id) => labelOf(html, id), page: p };
+}
+
+// ---------------------------------------------------------------------------
+// The cast. Substantial work = four shipped tasks paying 240 credits, which is
+// the shape the criterion's sentence describes.
+// ---------------------------------------------------------------------------
+
+// The four hops, as WORTHS. The task ids are minted per idea below, because a
+// removal is keyed by TASK: two ideas sharing a task id would share its death,
+// and the 'untouched twin' this proof leans on would not be untouched. (That
+// is not hypothetical — the first version of this file shared them, and the
+// twin came back dark.)
+const WORTHS = [120, 60, 40, 20];
+const TOTAL = WORTHS.reduce((a, b) => a + b, 0);
+// Idea 601 owns tasks 6011..6014, idea 602 owns 6021..6024, and so on.
+const tasksOf = (ideaId) => WORTHS.map((delta, i) => [Number(`${ideaId}${i + 1}`), delta]);
+const payFor = (ideaId) =>
+  tasksOf(ideaId).map(([taskId, delta]) => ({ reason: `idea.credit.task_ship:${ideaId}:${taskId}`, task_id: taskId, delta }));
+
+// 601 — the thought whose work the project tore out. 602 — its twin, untouched.
+// 603 — the thought that never caused anything at all.
+const DEAD = { id: 601, title: 'It caused a version, then the project removed it', status: 'promoted' };
+const LIVE = { id: 602, title: 'It caused the same work, and the work is still there', status: 'promoted' };
+const NEVER = { id: 603, title: 'It never caused anything', status: 'discarded' };
+
+function reset() {
+  creditLog = [...payFor(601), ...payFor(602)];
+  removals = new Map();
+}
+const kill = (taskId) => removals.set(String(taskId), { proposalTaskId: 990, paths: ['modules/gone/'] });
+// Everything idea 601 ever caused, torn out. 602 is never touched.
+const killAll = () => { for (const [taskId] of tasksOf(601)) kill(taskId); };
+
+// ═══ THE CRITERION'S OWN SCENARIO ══════════════════════════════════════════
+
+await test('THE SCENARIO: a large dead thought draws at FULL SIZE and ZERO brightness', async () => {
+  reset();
+  killAll();
+  const r = await render([DEAD, LIVE, NEVER]);
+  const dead = r.glyph(601);
+
+  assert.equal(dead.object, 'remnant', 'the ledger alone makes it a remnant — nothing set that');
+  assert.equal(dead.lit, 0, 'zero brightness: none of the work it caused is still alive');
+  // FULL SIZE, measured rather than promised: the diameter is computed from a
+  // `scale` the real size read produced AFTER the removal was confirmed.
+  const expected = 9 + (32 - 9) * compressIdeaSize(TOTAL);
+  assert.ok(Math.abs(dead.d - Math.round(expected)) <= 1,
+    `it keeps the diameter its 240 credits earn (${dead.d}px vs ~${expected.toFixed(1)}px)`);
+});
+
+await test('SIZE NEVER FELL — the dead thought is exactly as big as its untouched twin', async () => {
+  reset();
+  killAll();
+  const r = await render([DEAD, LIVE, NEVER]);
+  const dead = r.glyph(601);
+  const live = r.glyph(602);
+
+  // The two were paid identically; only one had its work removed. This is the
+  // claim hall_sky.mjs cannot make, because there the sizes were written by hand.
+  assert.equal(dead.d, live.d, 'removal took the light and left the size alone');
+  assert.equal(r.rows[0].size.credits, TOTAL, 'and the credits behind it are untouched too');
+  assert.equal(r.rows[0].size.credits, r.rows[1].size.credits);
+  assert.equal(live.lit, 1, 'while the twin is still fully lit');
+});
+
+await test('THE DISTINCTION: dead and never-caused do not render alike on EITHER channel', async () => {
+  reset();
+  killAll();
+  const r = await render([DEAD, LIVE, NEVER]);
+  const dead = r.glyph(601);
+  const never = r.glyph(603);
+
+  // Channel one — size. The whole reason there are two.
+  assert.ok(dead.d > never.d,
+    `the thought that mattered is visibly bigger (${dead.d}px vs ${never.d}px)`);
+  assert.equal(never.d, 9, 'a thought that caused nothing sits at the floor diameter');
+  // Channel two — brightness, and it runs the OPPOSITE way, which is the part a
+  // single number could never express: the dead one is dark, the never-caused
+  // one is LIT, because nothing has been taken from it.
+  assert.equal(dead.lit, 0);
+  assert.equal(never.lit, 1);
+  assert.notEqual(dead.object, never.object);
+});
+
+await test('and the distinction survives in WORDS, for a reader who cannot see the picture', async () => {
+  reset();
+  killAll();
+  const r = await render([DEAD, LIVE, NEVER]);
+  assert.match(r.label(601), /burned out/);
+  assert.match(r.label(601), /none of it still alive/);
+  assert.match(r.label(601), new RegExp(`size ${TOTAL}`), 'the size is spoken, not only drawn');
+  assert.match(r.label(603), /declined/);
+  assert.doesNotMatch(r.label(603), /still alive/,
+    'a thought that caused nothing says nothing about what survived — there is nothing to survive');
+});
+
+// ═══ the edges that make the two channels mean what they say ════════════════
+
+await test('ZERO OVER ZERO IS LIT, NOT DARK — a fresh thought is not a burned-out one', async () => {
+  reset();
+  killAll();
+  const fresh = { id: 604, title: 'Filed this morning', status: 'open' };
+  const r = await render([DEAD, fresh]);
+  const a = r.glyph(601);
+  const b = r.glyph(604);
+
+  assert.equal(b.object, 'protostar', 'nothing removed from it, because nothing came of it yet');
+  assert.equal(b.lit, 1, 'it is lit — returning 0 would merge it with the remnant');
+  assert.equal(a.lit, 0);
+  assert.ok(a.d > b.d, 'and the sizes part them too');
+
+  // THE SERVER'S OWN ANSWER, not only the drawing. This assertion exists
+  // because the case above it did NOT red when idea-brightness.js was made to
+  // return 0 for zero-over-zero: the renderer's `litOf` ignores the share
+  // entirely when `hasWork` is false, so the glyph stayed lit for a reason that
+  // had nothing to do with the rule this case is named after. A proof that
+  // names a failure mode and rides a different guard past it is the exact
+  // mistake docs/governance/bongos-v2-ideator-fork-proof.md records.
+  const freshState = r.rows[1].state;
+  assert.equal(freshState.hasWork, false, 'the server says there is no work');
+  assert.equal(freshState.brightness, 1,
+    'and it says the share is ONE — zero over zero is lit, because nothing has been taken away');
+});
+
+await test('brightness is weighted by WORTH, not by count — losing the big piece dims most', async () => {
+  reset();
+  // One of four tasks removed. By count that is 25%; by worth, 120 of 240.
+  kill(tasksOf(601)[0][0]); // the 120-credit hop of four
+  const r = await render([DEAD]);
+  const g = r.glyph(601);
+
+  assert.equal(g.object, 'star', 'partly dimmed is still burning — it goes out only when nothing survives');
+  assert.ok(Math.abs(g.lit - 0.5) < 0.001,
+    `the share is the payout that died, not the fraction of tasks (${g.lit})`);
+  assert.notEqual(g.lit, 0.75, 'which is what counting tasks would have given');
+  assert.equal(r.rows[0].size.credits, TOTAL, 'and the size still has not moved');
+});
+
+await test('a dimming thought stays the SAME SIZE the whole way down', async () => {
+  const widths = [];
+  const hops = tasksOf(601);
+  // nothing removed, then the smallest, then the two smallest, then all four
+  for (const doomed of [[], hops.slice(3), hops.slice(2), hops]) {
+    reset();
+    for (const [taskId] of doomed) kill(taskId);
+    const r = await render([DEAD]);
+    widths.push([r.glyph(601).d, r.glyph(601).lit]);
+  }
+  const diameters = widths.map((w) => w[0]);
+  assert.equal(new Set(diameters).size, 1, `one diameter the whole way down, got ${diameters.join(', ')}`);
+  const lits = widths.map((w) => w[1]);
+  assert.deepEqual(lits, [...lits].sort((a, b) => b - a), 'while the light falls monotonically');
+  assert.equal(lits[0], 1, 'from fully lit');
+  assert.equal(lits[lits.length - 1], 0, 'to fully out');
+});
+
+await test('AN UNREADABLE REMOVAL IS NOT A DEATH — it stays lit and full, and is never a remnant', async () => {
+  reset();
+  killAll();
+  // The port is gone: "we could not look" — a third answer, and the one most
+  // easily collapsed into "it died". Collapsing it renders a healthy instance
+  // as a field of hollow rings the moment the lifecycle module fails to mount.
+  // THE PORT IS PRESENT AND CANNOT ANSWER, which is the branch the real read
+  // actually takes: it tests `typeof port.confirmedRemovalsForTasks ===
+  // 'function'`. Swapping the RESOLVER instead does not work here and the
+  // reason is worth recording — idea-brightness.js destructures
+  // `const { resolveOptional } = api` at LOAD time, so a later property swap
+  // never reaches it (trail-removal.js avoids that on purpose and says so in
+  // its header; this module does not). Removing the method reaches the same
+  // branch through the door the code really uses.
+  const savedFn = removalsPort.confirmedRemovalsForTasks;
+  delete removalsPort.confirmedRemovalsForTasks;
+  try {
+    const r = await render([DEAD]);
+    const g = r.glyph(601);
+    assert.notEqual(g.object, 'remnant', 'an unread removal must never be drawn as a confirmed one');
+    assert.equal(g.lit, 1, 'the glyph stays FULL — the doubt goes in words, not in the picture');
+    assert.match(r.label(601), /unknown/, 'and the words say the share is unknown');
+    assert.ok(g.d > 9, 'the size, which never depended on the removal facts, is still drawn');
+  } finally {
+    removalsPort.confirmedRemovalsForTasks = savedFn;
+  }
+});
+
+await test('the object comes from the LEDGER, not from the status the row carries', async () => {
+  reset();
+  killAll();
+  // Same status as the live twin — `promoted`. Only the ledger differs, and the
+  // ledger is what decides. A resolver reading status would call both stars.
+  const r = await render([DEAD, LIVE]);
+  assert.equal(r.rows[0].status, r.rows[1].status, 'precondition: the two statuses agree');
+  assert.equal(r.glyph(601).object, 'remnant');
+  assert.equal(r.glyph(602).object, 'star');
+});
+
+console.log('');
+summary();