@bongos/core 1.19.1003 → 1.19.1005

package/tests/ideator_traceable_proof.mjs

@@ -0,0 +1,315 @@
+// tests/ideator_traceable_proof.mjs — THE PROOF for `ideator-nothing-is-lost`
+// (task 1004100 / BV2.R21 of goal 1000095, spec R06).
+//
+// THE SCENARIO THIS EXISTS FOR, stated as it actually happened on 2026-09-19:
+// a thought was filed from the hall, it silently became a task under a goal,
+// and the person who filed it could not find it five minutes later. Everything
+// in this scope was built so that cannot happen again. This file is the
+// re-runnable assertion that it cannot.
+//
+// WHY A PROOF AND NOT MORE UNIT TESTS. Every hop of this journey is already
+// covered on its own: the landing matrix (tests/idea_routing.mjs), the trail
+// projection (tests/idea_trail_descent.mjs), the five states
+// (tests/idea_state.mjs), the room's renderer (tests/hall_thinking_room.mjs).
+// What none of them can see is the JOIN between the filing moment and the
+// reading moment — that the goal a person is TOLD caught their thought is the
+// same goal the room attributes it to an hour later. A break there passes every
+// suite above and reproduces the original failure exactly: two surfaces, each
+// internally correct, disagreeing about one thought.
+//
+// SO THE CHAIN IS NEVER RE-TYPED. The trail row this proof reads an hour later
+// is DERIVED from what `captureIdea` actually did at filing time — the task id
+// it minted and the goal id it actually handed `lifecycle.createTask` — rather
+// than written out by hand beside it. A hand-written fixture would agree with
+// the filing because the author made it agree; this one can only agree if the
+// code does. (tests/helpers.mjs's own rule, and the reason
+// tests/hall_thinking_room.mjs shapes every row the way the route shapes one.)
+//
+// THE HOUR IS REAL, not a sleep. What "an hour later" means operationally is
+// that nothing from the filing session is still in hand: the receipt
+// (modules/hall-ui/public/ideas.js) is localStorage, so it is gone on another
+// device, in a private window, or after a storage clear. bootThinkingPage's
+// stub localStorage answers null to every read, which makes that the ONLY
+// condition this file can run under — the room has to answer from the server
+// or it does not answer at all.
+//
+// DB-free: captureIdea, the trail read and all three attachers take an injected
+// client, so the real SQL and the real composition run against a recorded query
+// log. A real-Postgres suite would SELF-SKIP on a machine with no database, and
+// a skipped test prints ok and counts as passed — which is how a green lane
+// hides what never ran.
+//
+// Run:  node tests/ideator_traceable_proof.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient, bootThinkingPage, settle } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+
+// The lifecycle port is how the ideas module reaches createTask (never an
+// import — the one-way module rule, ADR 0083). The CALL LOG is load-bearing
+// here and not incidental: `createTaskCalls[0].args.goalId` is the only
+// first-hand record of which goal actually caught the thought, and the whole
+// continuity assertion below is built on it rather than on the constant this
+// file passed in.
+const seams = require('../src/module-seams.js');
+seams._reset();
+let createTaskCalls = [];
+seams.registerProvider('lifecycle', {
+  createTask: async (args, deps) => {
+    createTaskCalls.push({ args, deps });
+    return { id: 9001, status: 'backlog', goal_id: args.goalId, title: args.title };
+  },
+});
+
+const inbox = require('../modules/ideas/inbox.js');
+const { captureIdea } = inbox;
+const trail = require('../modules/ideas/trail.js');
+const { attachDescentToTrail } = require('../modules/ideas/trail-descent.js');
+const { attachSizeToTrail } = require('../modules/ideas/trail-size.js');
+const { attachStateToTrail } = require('../modules/ideas/idea-state.js');
+
+const { test, summary } = makeRunner();
+
+// ---------------------------------------------------------------------------
+// the world
+// ---------------------------------------------------------------------------
+
+const FILER = 42;
+// A routable goal: open, on a version that is still building — the shape
+// routing.js requires before it will let a filing land as work.
+const LIVE_GOAL = { id: 7, status: 'open', version_id: 'BONGOS-V2', version_status: 'building' };
+const THOUGHT = 'the filing receipt does not survive a reload';
+
+function fakePool(handler) {
+  const c = makeSqlAwareClient(handler);
+  return {
+    query: (sql, params) => c._client.query(sql, params),
+    connect: c.connect,
+    queries: c._client.queries,
+  };
+}
+
+// The idea row the INSERT returns. `id` and `captured_by` are the two fields
+// every later read keys on, so they are the two this proof carries forward.
+function ideaRow(over = {}) {
+  return {
+    id: 555, title: THOUGHT, body_md: '', kind: 'bug',
+    suggested_version: null, suggested_priority: null,
+    captured_at: '2026-09-19T09:00:00.000Z', captured_by: FILER,
+    status: 'open', promoted_to_task_id: null, reviewed_at: null,
+    merged_into_idea_id: null, triage_note: null, suggested_goal_id: null,
+    ...over,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// THE FILING MOMENT — one line, one gesture
+// ---------------------------------------------------------------------------
+
+// Files `THOUGHT` through the REAL captureIdea and hands back both halves of
+// what the hall learns at that instant: the capture result (which is what
+// ideas.js builds its receipt line from — `routed_task.id` and
+// `routing.goal_id`, see fileQuick) and the goal createTask was actually given.
+async function fileIt({ goalId }) {
+  createTaskCalls = [];
+  const pool = fakePool((s) => {
+    if (/FROM goals g JOIN versions v/.test(s)) return { rows: [LIVE_GOAL] };
+    if (/INSERT INTO idea_inbox/.test(s)) {
+      return { rows: [ideaRow(goalId ? { status: 'promoted', suggested_goal_id: goalId } : {})] };
+    }
+    return null;
+  });
+  const captured = await captureIdea({
+    title: THOUGHT,
+    kind: 'bug',
+    capturedBy: FILER,
+    filerRank: 'archon',
+    ...(goalId ? { goalId } : {}),
+  }, { pool });
+  return { captured, createTaskCalls: createTaskCalls.slice() };
+}
+
+// ---------------------------------------------------------------------------
+// AN HOUR LATER — the room, from the server alone
+// ---------------------------------------------------------------------------
+
+// Reads the trail the way GET /inbox/by-builder/:id reads it: the real
+// projection, then the same three attachers in the same order the route
+// composes them. The row handed to the SQL layer is BUILT FROM `filed` — what
+// the filing actually did — so nothing in this function can make the two
+// moments agree on its own.
+async function anHourLater(filed) {
+  const routed = filed.captured.routing && filed.captured.routing.routed
+    ? filed.captured
+    : null;
+  const call = filed.createTaskCalls[0];
+
+  const row = {
+    ...ideaRow(),
+    status: routed ? 'promoted' : 'open',
+    // The three fields the trail projection carries about a promotion, each
+    // taken from the filing rather than restated: the task it minted, that
+    // task's goal, that task's status.
+    promoted_to_task_id: routed ? routed.routed_task.id : null,
+    promoted_task_goal_id: routed ? call.args.goalId : null,
+    promoted_task_status: routed ? routed.routed_task.status : null,
+    promoted_task_title: routed ? routed.routed_task.title : null,
+    merged_into_idea_title: null, merged_into_idea_status: null,
+    lineage_tasks: routed
+      ? [{
+        task_id: routed.routed_task.id, origin: 'route',
+        title: routed.routed_task.title, status: routed.routed_task.status,
+        goal_id: call.args.goalId,
+      }]
+      : [],
+  };
+
+  const client = makeSqlAwareClient((s) => {
+    if (/FROM idea_inbox i/.test(s)) return { rows: [row] };
+    return { rows: [] };
+  })._client;
+
+  const ideas = await trail.listIdeaTrailForBuilder(FILER, {}, { pool: client });
+  // The route's own order, and its reasons: the walk, then what it paid, then
+  // which of the five objects it is.
+  await attachDescentToTrail(ideas, { client });
+  await attachSizeToTrail(ideas, { client });
+  await attachStateToTrail(ideas, { client });
+  return { ideas, total: ideas.length, limit: 50, offset: 0 };
+}
+
+// Boots the REAL room over a REAL trail response and hands back the HTML a
+// reader is actually shown. No receipt is reachable from here: bootThinkingPage's
+// localStorage answers null, which is the "another device, an hour later"
+// condition this proof is about.
+async function room(page) {
+  const p = bootThinkingPage({ pages: [{ ...page, offset: 0 }], viewer: { id: FILER } });
+  for (let i = 0; i < 10; i += 1) await settle();
+  return p;
+}
+
+// =========================================================================
+// 1. AIMED — the thought that was caught
+// =========================================================================
+
+await test('aimed: filing one line lands it as work, and the hall is told so at that instant', async () => {
+  const filed = await fileIt({ goalId: LIVE_GOAL.id });
+  const r = filed.captured;
+  assert.equal(r.routing.routed, true, 'a goal was named, so the filing lands as work');
+  assert.equal(filed.createTaskCalls.length, 1, 'exactly one task is minted');
+  // The two fields fileQuick (modules/hall-ui/public/ideas.js) reads to write
+  // the receipt line "Filed as task N under <goal>." Both must be on the
+  // response or the receipt cannot name either.
+  assert.ok(r.routed_task && r.routed_task.id, 'the response names the task it became');
+  assert.ok(r.routing.goal_id, 'the response names the goal that caught it');
+  assert.equal(r.routing.goal_id, filed.createTaskCalls[0].args.goalId,
+    'the goal the filer is TOLD about is the goal the task was actually created in');
+});
+
+await test('aimed: AN HOUR LATER the room still names what it became, with no receipt in reach', async () => {
+  const filed = await fileIt({ goalId: LIVE_GOAL.id });
+  const page = await anHourLater(filed);
+  const rows = (await room(page)).rows();
+
+  assert.match(rows, /the filing receipt does not survive a reload/, 'the thought is on the page');
+  // "What became of it" — the task, by NAME and as a link. This is the answer
+  // the 2026-09-19 filing could not get.
+  assert.match(rows, new RegExp(`/task/${filed.captured.routed_task.id}\\b`),
+    'the row links the task the thought became');
+  assert.doesNotMatch(rows, /nothing yet/,
+    'a thought that became work is never drawn as one that caused none');
+});
+
+await test('aimed: the goal that caught it survives the hour — the room attributes it to the SAME well', async () => {
+  // THE CONTINUITY ASSERTION, and the only one here that no other suite makes.
+  // Everything else in this file could hold while the two moments still named
+  // two different goals.
+  const filed = await fileIt({ goalId: LIVE_GOAL.id });
+  const page = await anHourLater(filed);
+  const st = page.ideas[0].state;
+
+  assert.equal(st.position, 'well', 'an aimed thought sits in a goal, not in open space');
+  assert.equal(String(st.wellGoalId), String(filed.captured.routing.goal_id),
+    'the goal the room resolves is the goal the receipt named at filing');
+});
+
+// =========================================================================
+// 2. FLOATED — the thought nothing has claimed
+// =========================================================================
+
+await test('floated: letting it float is a recorded outcome, not a failure to route', async () => {
+  const filed = await fileIt({ goalId: null });
+  assert.equal(filed.captured.routing.routed, false, 'no goal named, so nothing is minted');
+  assert.equal(filed.captured.routing.reason, 'no_goal', 'and the reason is recorded');
+  assert.equal(filed.createTaskCalls.length, 0, 'no task exists to find later');
+});
+
+await test('floated: an hour later the room says nothing has claimed it — in those words', async () => {
+  const filed = await fileIt({ goalId: null });
+  const page = await anHourLater(filed);
+  const st = page.ideas[0].state;
+
+  assert.equal(st.state, 'protostar', 'filed, not yet ignited');
+  assert.equal(st.position, 'open-space', 'and nothing caught it');
+
+  const rows = (await room(page)).rows();
+  assert.match(rows, /the filing receipt does not survive a reload/, 'the thought is still on the page');
+  assert.match(rows, /nothing has claimed it/,
+    'the room says so in the reader\'s words, not by leaving the cell blank');
+});
+
+// =========================================================================
+// 3. THE DISTINCTION — the failure mode this whole scope exists for
+// =========================================================================
+
+await test('the two outcomes do not render alike — a caught thought and a floating one are told apart at a glance', async () => {
+  // The original failure was not that the answer was WRONG. It was that a
+  // thought which had quietly become work looked exactly like one that had gone
+  // nowhere. Both rows rendering is not the property; them rendering
+  // DIFFERENTLY is.
+  const aimedRows = (await room(await anHourLater(await fileIt({ goalId: LIVE_GOAL.id })))).rows();
+  const floatRows = (await room(await anHourLater(await fileIt({ goalId: null })))).rows();
+
+  assert.notEqual(aimedRows, floatRows, 'the two rows are not the same HTML');
+  assert.match(aimedRows, /data-object="protostar"/, 'both are protostars — neither has been paid yet');
+  assert.match(floatRows, /data-object="protostar"/);
+  // …and the object column is what separates them, which is exactly the
+  // position axis idea-objects.js says is load-bearing for a protostar alone.
+  assert.doesNotMatch(aimedRows, /nothing has claimed it/,
+    'the caught thought must never be described as unclaimed');
+  assert.match(floatRows, /nothing has claimed it/);
+});
+
+// =========================================================================
+// 4. HOW FAR THE CHAIN GETS BEFORE A GOAL IS NAMED — recorded, not assumed
+// =========================================================================
+
+await test('the room reaches the goal by LINK, not by name — pinned so the follow-up is visible', async () => {
+  // HONEST LIMIT OF THIS PROOF. The criterion asks that a person can answer
+  // "what happened to the thing I filed" unaided, and they can: the row names
+  // the task and links it, and the task record names its goal. What the room
+  // does NOT do is print the goal's own name, even though `state.wellGoalId`
+  // is resolved server-side and sits on the row it draws (idea-objects.js
+  // positionWord deliberately returns "has a home" / "waiting for a nod" and
+  // never the well's identity).
+  //
+  // That is a rendering gap, not a traceability one, so it is recorded here
+  // rather than fixed under a verify task (it is task 1004225) — and pinned, so that when the room
+  // does start naming the well this assertion fails and is deleted along with
+  // the follow-up it points at.
+  const filed = await fileIt({ goalId: LIVE_GOAL.id });
+  const page = await anHourLater(filed);
+  const rows = (await room(page)).rows();
+
+  assert.ok(page.ideas[0].state.wellGoalId, 'the well IS resolved and delivered to the page');
+  assert.doesNotMatch(rows, new RegExp(`goal ${LIVE_GOAL.id}\\b`),
+    'and today the page does not print it — the goal is one link away, on the task');
+  assert.match(rows, /has a home|waiting for a nod/,
+    'what it prints instead is the position, which says a goal caught it without saying which');
+});
+
+summary();

package/tests/task_lib.mjs

@@ -111,5 +111,30 @@ t('rankTagHtml escapes its label and treats xenos as "no floor"', () => {
   assert.doesNotMatch(T.rankTagHtml('<img src=x onerror=1>'), /<img/);
 });
 
+// ---- conflictPeers / conflictChipHtml (task 1001741) ----------------------
+t('conflictPeers names colliding tasks: excludes self, dedupes, sorts numerically', () => {
+  const me = { id: 5, touches: ['src/'] };
+  const pool = [
+    { id: 5, touches: ['src/'] },              // self
+    { id: 20, touches: ['src/a.js'] },
+    { id: 3, touches: ['src/b.js'] },
+    { id: 20, touches: ['src/a.js'] },         // duplicate id in the pool
+    { id: 9, touches: ['docs/'] },             // disjoint
+    { id: 11, touches: [] },                   // no touches never collides
+  ];
+  assert.deepEqual(T.conflictPeers(me, pool), [3, 20]);
+  assert.deepEqual(T.conflictPeers({ id: 1, touches: [] }, pool), []);
+  assert.deepEqual(T.conflictPeers(me, null), []);
+});
+
+t('conflictChipHtml: empty for none, count + capped list for many', () => {
+  assert.equal(T.conflictChipHtml([]), '');
+  assert.match(T.conflictChipHtml([2, 3]), /overlaps 2/);
+  const many = T.conflictChipHtml([1, 2, 3, 4, 5, 6, 7]);
+  assert.match(many, /overlaps 7/);
+  assert.match(many, /#1, #2, #3, #4, #5, …/, 'the tooltip lists five and ellipsises the rest');
+  assert.doesNotMatch(many, /#6/);
+});
+
 console.log(`\ntask-lib tests: ${passed} passed, ${failed} failed`);
 if (failed) process.exit(1);