@bongos/core 1.19.900 → 1.19.902

package/tests/idea_trail_descent.mjs

@@ -0,0 +1,399 @@
+// tests/idea_trail_descent.mjs
+//
+// task 1004089 (BV2.R09, goal 1000095) — the idea trail read to the FULL depth
+// of the descent, and across version boundaries. ADR 0312; spec
+// docs/specs/bongos-v2-ideator-surface.md.
+//
+// WHAT IS PINNED HERE, AND WHY EACH ONE IS INVISIBLE IN REVIEW. The three
+// findings inherited from the abandoned task 1004054 are the spine of this file:
+//
+//   1. THE RENDERED LAYER IS TESTED, not only the read behind it. The prior
+//      attempt asserted on the server-side builder alone, and that is exactly
+//      how finding 2 survived it. Half of this file boots the REAL
+//      modules/hall-ui/public/profile.js (tests/helpers.mjs bootProfilePage)
+//      and asserts on the HTML a reader would actually be handed.
+//   2. A MERGED IDEA SHOWS ITS OWN TRIAGE NOTE beside the descent it inherited
+//      from the idea it merged INTO. Both halves matter and they pull in
+//      opposite directions: the tasks come from the target, the sentence stays
+//      on the merged row. Getting this backwards renders one person's triage
+//      note under another person's thought, and every row still paints.
+//   3. THE ROUND TRIPS DO NOT SCALE WITH THE PAGE. The count tracks the DEPTH
+//      of the deepest descent and nothing else, so a page of thirty ideas costs
+//      what a page of one costs. Nothing about the output changes when this
+//      regresses — it just gets slower, quietly, in production.
+//
+// DB-free: every reader takes an injected { client }, so the real SQL and the
+// real walk 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/idea_trail_descent.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { bootProfilePage, settle } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const trailDescent = require('../modules/ideas/trail-descent.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))}`); }
+}
+
+// ---------------------------------------------------------------------------
+// the fixture world
+// ---------------------------------------------------------------------------
+
+// A four-deep chain below one root, with the third hop landing in a LATER
+// version — the case the read has to carry rather than filter.
+const EDGES = [
+  { task_id: 5002, parent_task_id: 5001, relation: 'split' },
+  { task_id: 5003, parent_task_id: 5002, relation: 'cascade' },
+  { task_id: 5004, parent_task_id: 5003, relation: 'fold' },
+];
+const TASKS = {
+  5001: { id: 5001, title: 'The first task', status: 'shipped', version_id: 'BONGOS-V2', kind: 'feature' },
+  5002: { id: 5002, title: 'Split out of the first', status: 'shipped', version_id: 'BONGOS-V2', kind: 'feature' },
+  5003: { id: 5003, title: 'A cascade, next version', status: 'ready', version_id: 'BONGOS-V3', kind: 'bug' },
+  5004: { id: 5004, title: 'Folded in', status: 'abandoned', version_id: 'BONGOS-V3', kind: 'cleanup' },
+};
+
+// An SQL-aware client that answers the three shapes this read issues, off real
+// data rather than canned rows, and records every query it was asked for.
+function fakeClient({ edges = EDGES, tasks = TASKS, lineage = {}, promoted = {} } = {}) {
+  const log = [];
+  return {
+    log,
+    query: async (text, params) => {
+      log.push({ text, params });
+      if (/FROM idea_inbox/.test(text)) {
+        // the merge follow: target idea ids -> their lineage task ids
+        const rows = [];
+        for (const ideaId of params[0].map(String)) {
+          const tasksFor = lineage[ideaId] || [];
+          if (tasksFor.length === 0) {
+            rows.push({ idea_id: ideaId, promoted_to_task_id: promoted[ideaId] ?? null, task_id: null });
+          }
+          for (const t of tasksFor) {
+            rows.push({ idea_id: ideaId, promoted_to_task_id: promoted[ideaId] ?? null, task_id: t });
+          }
+        }
+        return { rows };
+      }
+      if (/FROM ideas_task_descent/.test(text)) {
+        const frontier = params[0].map(Number);
+        return {
+          rows: edges
+            .filter((e) => frontier.includes(Number(e.parent_task_id)))
+            .map((e) => ({ id: e.task_id, from_id: e.parent_task_id, relation: e.relation })),
+        };
+      }
+      if (/FROM tasks/.test(text)) {
+        return { rows: params[0].map((id) => tasks[Number(id)]).filter(Boolean) };
+      }
+      return { rows: [] };
+    },
+  };
+}
+
+const promotedIdea = (id, rootTaskIds) => ({
+  id: String(id), title: `Idea ${id}`, status: 'promoted', triage_note: null,
+  lineage_tasks: rootTaskIds.map((t) => ({ task_id: String(t), origin: 'promote', title: TASKS[t]?.title ?? '', status: 'shipped' })),
+});
+
+const walkQueries = (c) => c.log.filter((q) => /FROM ideas_task_descent/.test(q.text)).length;
+
+// ---------------------------------------------------------------------------
+// 1. the read — depth, versions, and the round-trip budget
+// ---------------------------------------------------------------------------
+
+await test('the descent reads to ARBITRARY DEPTH, not one hop', async () => {
+  const c = fakeClient();
+  const [idea] = await trailDescent.attachDescentToTrail([promotedIdea(901, [5001])], { client: c });
+  assert.deepEqual(idea.descent_tasks.map((t) => t.task_id), ['5002', '5003', '5004'],
+    'every descendant below the idea, nearest first — not just the first hop');
+  assert.deepEqual(idea.descent_tasks.map((t) => t.depth), [1, 2, 3]);
+  assert.deepEqual(idea.descent_tasks.map((t) => t.relation), ['split', 'cascade', 'fold'],
+    'each edge says HOW the work descended, which is what the surface reads');
+});
+
+await test('the descent CROSSES VERSIONS, and says which version it crossed into', async () => {
+  const c = fakeClient();
+  const [idea] = await trailDescent.attachDescentToTrail([promotedIdea(901, [5001])], { client: c });
+  const crossed = idea.descent_tasks.find((t) => t.task_id === '5003');
+  assert.ok(crossed, 'a descendant in a LATER version is still in the descent');
+  assert.equal(crossed.version_id, 'BONGOS-V3', 'and it carries its own version, so a surface can mark it');
+  for (const q of c.log) {
+    assert.doesNotMatch(String(q.text), /version_id\s*=/,
+      'no read may filter on version — a version boundary does not end an origin tag');
+  }
+});
+
+await test('the ROUND TRIPS track DEPTH, not the size of the page', async () => {
+  // Thirty ideas, each rooted at its own task, each with the same three-deep
+  // chain below it. Walked one idea at a time this is ninety-odd round trips;
+  // batched it is the same handful a single idea costs. That difference is the
+  // whole of finding 3, and it is invisible in the output.
+  const edges = [];
+  const tasks = {};
+  const many = [];
+  for (let i = 0; i < 30; i += 1) {
+    const root = 6000 + i * 10;
+    tasks[root] = { id: root, title: `Root ${i}`, status: 'shipped', version_id: 'BONGOS-V2', kind: 'feature' };
+    for (let d = 1; d <= 3; d += 1) {
+      tasks[root + d] = { id: root + d, title: `Below ${i}.${d}`, status: 'ready', version_id: 'BONGOS-V2', kind: 'feature' };
+      edges.push({ task_id: root + d, parent_task_id: root + d - 1, relation: 'split' });
+    }
+    many.push(promotedIdea(7000 + i, [root]));
+  }
+
+  const one = fakeClient({ edges, tasks });
+  await trailDescent.attachDescentToTrail([many[0]], { client: one });
+  const page = fakeClient({ edges, tasks });
+  const out = await trailDescent.attachDescentToTrail(many, { client: page });
+
+  assert.equal(out.length, 30);
+  assert.equal(out[29].descent_tasks.length, 3, 'the thirtieth idea got its full descent, not a truncated one');
+  assert.equal(walkQueries(page), walkQueries(one),
+    `a page of 30 must cost the walk queries a page of 1 costs — got ${walkQueries(page)} vs ${walkQueries(one)}`);
+  assert.equal(page.log.length, one.log.length,
+    'and the same total, because the hydration is batched too');
+});
+
+await test('a descendant reachable from TWO of one idea roots resolves ONCE, at the shorter depth', async () => {
+  // 5001 -> 5002 -> 5009 and 5008 -> 5009: the idea owns both 5001 and 5008, so
+  // 5009 is at depth 2 from one root and depth 1 from the other. Counting it
+  // twice would pay the same origin twice for one piece of work (ADR 0312).
+  const edges = [
+    { task_id: 5002, parent_task_id: 5001, relation: 'split' },
+    { task_id: 5009, parent_task_id: 5002, relation: 'cascade' },
+    { task_id: 5009, parent_task_id: 5008, relation: 'split' },
+  ];
+  const tasks = {
+    ...TASKS,
+    5008: { id: 5008, title: 'The other root', status: 'shipped', version_id: 'BONGOS-V2', kind: 'feature' },
+    5009: { id: 5009, title: 'Reachable twice', status: 'ready', version_id: 'BONGOS-V2', kind: 'feature' },
+  };
+  const c = fakeClient({ edges, tasks });
+  const [idea] = await trailDescent.attachDescentToTrail([promotedIdea(901, [5001, 5008])], { client: c });
+  const hits = idea.descent_tasks.filter((t) => t.task_id === '5009');
+  assert.equal(hits.length, 1, 'once, never twice');
+  assert.equal(hits[0].depth, 1, 'at the SHORTEST depth of the two');
+  assert.equal(hits[0].origin_task_id, '5008', 'and attributed to the root that reached it soonest');
+});
+
+await test('an idea OWN tasks are not repeated below it as their own descendants', async () => {
+  // 5001 and 5002 both belong to the idea, and 5002 descends from 5001. The
+  // trail already shows 5002 as something the idea BECAME; showing it again as
+  // something it CAUSED double-counts the first hop.
+  const c = fakeClient();
+  const [idea] = await trailDescent.attachDescentToTrail([promotedIdea(901, [5001, 5002])], { client: c });
+  assert.deepEqual(idea.descent_tasks.map((t) => t.task_id), ['5003', '5004']);
+});
+
+await test('an idea that caused nothing gets an EMPTY descent, not a missing key', async () => {
+  const c = fakeClient({ edges: [] });
+  const [idea] = await trailDescent.attachDescentToTrail([promotedIdea(901, [5001])], { client: c });
+  assert.deepEqual(idea.descent_tasks, [], 'empty is an answer the renderer can act on');
+});
+
+await test('an idea with NO tasks costs no walk at all', async () => {
+  const c = fakeClient();
+  const [idea] = await trailDescent.attachDescentToTrail(
+    [{ id: '904', title: 'Still thinking', status: 'open', lineage_tasks: [] }], { client: c });
+  assert.deepEqual(idea.descent_tasks, []);
+  assert.equal(c.log.length, 0, 'nothing to walk from means nothing is asked of the database');
+});
+
+await test('a non-numeric task id never reaches SQL', async () => {
+  const c = fakeClient();
+  const idea = {
+    id: '901', status: 'promoted',
+    lineage_tasks: [{ task_id: 'DROP TABLE tasks' }, { task_id: '5001' }],
+  };
+  await trailDescent.attachDescentToTrail([idea], { client: c });
+  for (const q of c.log) {
+    const flat = JSON.stringify(q.params);
+    assert.doesNotMatch(flat, /DROP TABLE/, 'a root that is not a positive integer is dropped before the query');
+  }
+  assert.deepEqual(idea.descent_tasks.map((t) => t.task_id), ['5002', '5003', '5004'],
+    'and the legitimate root beside it still walks');
+});
+
+// ---------------------------------------------------------------------------
+// 2. the merge — finding 2, in both directions
+// ---------------------------------------------------------------------------
+
+await test('a MERGED idea inherits the descent of the idea it merged INTO', async () => {
+  const c = fakeClient({ lineage: { 901: [5001] } });
+  const merged = {
+    id: '903', title: 'A duplicate', status: 'merged',
+    merged_into_idea_id: '901', merged_into_idea_title: 'A shared changelog',
+    triage_note: 'Same thought as #901.', lineage_tasks: [],
+  };
+  const [idea] = await trailDescent.attachDescentToTrail([merged], { client: c });
+  assert.deepEqual(idea.descent_tasks.map((t) => t.task_id), ['5002', '5003', '5004'],
+    'nothing is lost: a merged thought still sees the work it caused through its target');
+});
+
+await test('the merge follow reads TASK IDS only — no prose travels from the target', async () => {
+  const c = fakeClient({ lineage: { 901: [5001] } });
+  await trailDescent.attachDescentToTrail([{
+    id: '903', status: 'merged', merged_into_idea_id: '901',
+    triage_note: 'Same thought as #901.', lineage_tasks: [],
+  }], { client: c });
+  const follow = c.log.find((q) => /FROM idea_inbox/.test(q.text));
+  assert.ok(follow, 'the merge is followed in one query');
+  assert.doesNotMatch(follow.text, /triage_note|body_md|\bi\.title\b/,
+    'the target row must not hand back prose — that is how a merged idea ends up wearing somebody else triage note');
+});
+
+await test('the merge follow is ONE query however many merges the page carries', async () => {
+  const c = fakeClient({ lineage: { 901: [5001], 902: [5001] } });
+  const page = [];
+  for (let i = 0; i < 8; i += 1) {
+    page.push({ id: String(910 + i), status: 'merged', merged_into_idea_id: i % 2 ? '901' : '902', lineage_tasks: [] });
+  }
+  await trailDescent.attachDescentToTrail(page, { client: c });
+  assert.equal(c.log.filter((q) => /FROM idea_inbox/.test(q.text)).length, 1);
+});
+
+// ---------------------------------------------------------------------------
+// 3. the RENDERED layer — finding 1
+// ---------------------------------------------------------------------------
+
+// The trail payload as the route now returns it: the existing four outcomes,
+// each carrying the descent the read attached.
+const RENDER_TRAIL = [
+  {
+    id: '901', title: 'A shared changelog', status: 'promoted', captured_at: '2026-08-01T00:00:00Z',
+    lineage_tasks: [{ task_id: '5001', origin: 'promote', title: 'The first task', status: 'shipped' }],
+    descent_tasks: [
+      { task_id: '5002', depth: 1, relation: 'split', origin_task_id: '5001', title: 'Split out of the first', status: 'shipped', version_id: 'BONGOS-V2', kind: 'feature' },
+      { task_id: '5003', depth: 2, relation: 'cascade', origin_task_id: '5001', title: 'A cascade, next version', status: 'ready', version_id: 'BONGOS-V3', kind: 'bug' },
+    ],
+  },
+  {
+    id: '903', title: 'A duplicate', status: 'merged', captured_at: '2026-06-01T00:00:00Z',
+    merged_into_idea_id: '901', merged_into_idea_title: 'A shared changelog',
+    triage_note: 'Same thought as the changelog one.',
+    lineage_tasks: [],
+    descent_tasks: [
+      { task_id: '5002', depth: 1, relation: 'split', origin_task_id: '5001', title: 'Split out of the first', status: 'shipped', version_id: 'BONGOS-V2', kind: 'feature' },
+    ],
+  },
+  {
+    id: '904', title: 'Still thinking', status: 'open', captured_at: '2026-05-01T00:00:00Z',
+    lineage_tasks: [], descent_tasks: [],
+  },
+];
+
+const renderTrail = async (trail) => {
+  const p = bootProfilePage({ trail });
+  await settle(); await settle(); await settle();
+  const html = p.htmlFor('activity-ideas');
+  assert.ok(html, 'the idea trail rendered');
+  return html;
+};
+
+await test('RENDERED: the descent is on the page, linked and named', async () => {
+  const html = await renderTrail(RENDER_TRAIL);
+  assert.ok(html.includes('/task/5002'), 'a descendant is a link, not a bare number');
+  assert.ok(html.includes('Split out of the first'), 'and it is named, so the reader need not go look it up');
+  assert.ok(html.includes('/task/5003'), 'to the full depth, not just the first hop');
+});
+
+await test('RENDERED: a descendant in ANOTHER version says so on the page', async () => {
+  const html = await renderTrail(RENDER_TRAIL);
+  assert.ok(html.includes('BONGOS-V3'),
+    'the cross-version case is the proof the origin tag survived a version boundary — it is labelled, not hidden');
+});
+
+await test('RENDERED: a MERGED idea shows the inherited tasks AND ITS OWN triage note', async () => {
+  // The headline scenario, and the one the prior attempt got backwards.
+  const html = await renderTrail(RENDER_TRAIL);
+  assert.ok(html.includes('Same thought as the changelog one.'),
+    "the note beside a merged idea is the note written about THAT idea");
+  assert.ok(/Merged into/.test(html) && html.includes('/idea/901'),
+    'and it still says which idea absorbed it');
+  const mergedRow = html.split('Merged into')[1] || '';
+  assert.ok(mergedRow.includes('/task/5002'),
+    'with the descent it inherited through the target rendered under it');
+});
+
+await test('RENDERED: an idea that caused nothing paints NO descent block', async () => {
+  const html = await renderTrail(RENDER_TRAIL);
+  const openRow = html.split('Still open')[1] || '';
+  assert.doesNotMatch(openRow, /Then caused/,
+    'an empty descent is silence, not a row announcing zero');
+});
+
+await test('RENDERED: beyond the cap, the overflow is a LINK, not a truncation', async () => {
+  const many = {
+    id: '905', title: 'A fertile thought', status: 'promoted', captured_at: '2026-04-01T00:00:00Z',
+    lineage_tasks: [{ task_id: '5001', origin: 'promote', title: 'The first task', status: 'shipped' }],
+    descent_tasks: Array.from({ length: 9 }, (_, i) => ({
+      task_id: String(5100 + i), depth: 1 + i, relation: 'split', origin_task_id: '5001',
+      title: `Descendant ${i}`, status: 'ready', version_id: 'BONGOS-V2', kind: 'feature',
+    })),
+  };
+  const html = await renderTrail([many]);
+  assert.ok(html.includes('Then caused 9 tasks'), 'the COUNT is honest even where the list is capped');
+  assert.ok(/and 3 more/.test(html), 'and the remainder is named');
+  assert.ok(html.includes('/idea/905'), 'as a link to the page that shows the whole descent');
+});
+
+await test('RENDERED: a hostile descendant title cannot inject markup', async () => {
+  const hostile = {
+    id: '906', title: 'A thought', status: 'promoted', captured_at: '2026-03-01T00:00:00Z',
+    lineage_tasks: [{ task_id: '5001', origin: 'promote', title: 'The first task', status: 'shipped' }],
+    descent_tasks: [{
+      task_id: '5200', depth: 1, relation: '<img src=x onerror=alert(1)>', origin_task_id: '5001',
+      title: '<script>alert(1)</script>', status: 'ready', version_id: '"><b>V</b>', kind: 'feature',
+    }],
+  };
+  const html = await renderTrail([hostile]);
+  assert.doesNotMatch(html, /<script>/, 'the title is escaped');
+  // The ANGLE BRACKETS are what makes markup, not the attribute text: an
+  // escaped `&lt;img … onerror=…&gt;` is inert prose and must stay READABLE, so
+  // the assertion is that no live tag opened, never that the substring is gone.
+  assert.doesNotMatch(html, /<img/, 'the relation cannot open a tag either, DB enum or not');
+  assert.ok(html.includes('&lt;img'), 'it is escaped into visible text, not silently swallowed');
+  assert.doesNotMatch(html, /"><b>/, 'and the version, which rides into an attribute-adjacent position');
+  assert.ok(html.includes('&lt;script&gt;'), 'escaped, not stripped — the reader still sees what was there');
+});
+
+// ---------------------------------------------------------------------------
+// 4. the WHOLE path — the read feeding the renderer, not a fixture between them
+// ---------------------------------------------------------------------------
+
+// WHY THIS EXISTS SEPARATELY from the rendered tests above. Those hand-build the
+// payload, which makes them sharp about the PAGE and blind to the READ: a bug
+// that puts the target's triage note on the merged row happens server-side, and
+// a hand-written fixture that does not have that bug renders perfectly. So the
+// headline scenario is asserted once with nothing hand-built in the middle —
+// the real attachDescentToTrail output goes straight into the real page.
+await test('WHOLE PATH: the real read feeds the real page, and the merged note is the merged idea own', async () => {
+  const c = fakeClient({ lineage: { 901: [5001] } });
+  const trail = await trailDescent.attachDescentToTrail([
+    {
+      id: '903', title: 'A duplicate', status: 'merged', captured_at: '2026-06-01T00:00:00Z',
+      merged_into_idea_id: '901', merged_into_idea_title: 'A shared changelog',
+      triage_note: 'Same thought as the changelog one.', lineage_tasks: [],
+    },
+  ], { client: c });
+
+  const html = await renderTrail(trail);
+  assert.ok(html.includes('Same thought as the changelog one.'),
+    'the sentence on the page is the one written about THIS idea — not the target it merged into');
+  assert.ok(html.includes('/task/5002') && html.includes('/task/5004'),
+    'while the tasks under it are the ones inherited through the target, to full depth');
+  assert.ok(html.includes('BONGOS-V3'),
+    'including the hop that crossed a version boundary');
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/profile_activity.mjs

@@ -35,7 +35,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
-import { assertCannotSwallow } from './helpers.mjs';
+import { assertCannotSwallow, bootProfilePage, settle } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -421,7 +421,9 @@ await test('a ledger cannot be both client-sliced and server-paged', () => {
 // 6. the page — the four outcomes, the craft axis, and the signed-out state
 // ---------------------------------------------------------------------------
 
-const PROFILE_JS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile.js'), 'utf8');
+// The harness that boots the real page lives in tests/helpers.mjs, shared with
+// tests/idea_trail_descent.mjs (task 1004089) so one page has one stub DOM.
+const bootProfile = (opts = {}) => bootProfilePage({ ...opts, trail: TRAIL });
 
 // The four outcomes the criterion names, one row each. `open` is included
 // precisely because it must read as an outcome and not as an absence.
@@ -436,127 +438,7 @@ const TRAIL = [
   { id: '904', title: 'Still thinking', status: 'open', captured_at: '2026-05-01T00:00:00Z' },
 ];
 
-// Boot the REAL profile.js against a stub DOM + a stub OTBKit that captures each
-// ledger's rowHtml, and return what it rendered plus every request it made.
-function bootProfile({ signedIn = true } = {}) {
-  const els = new Map();
-  const makeEl = () => ({
-    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
-    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
-    setAttribute() {}, getAttribute() { return null; },
-    addEventListener() {},
-    querySelector() { return makeEl(); }, querySelectorAll() { return []; }, appendChild() {},
-    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
-  });
-  const documentObj = {
-    title: '',
-    body: { dataset: { page: 'profile' } },
-    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
-    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
-    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
-    querySelectorAll() { return []; },
-    createElement() { return makeEl(); },
-    addEventListener() {},
-  };
-
-  const requests = [];
-  const client = {
-    request: async (method, url) => {
-      requests.push(url);
-      if (url.endsWith('/me')) {
-        return signedIn
-          ? { status: 200, ok: true, data: { builder: { id: 95, rank: 'metic' } } }
-          : { status: 401, ok: false, data: null };
-      }
-      if (/\/builders\/\d+\/profile$/.test(url)) {
-        return { status: 200, ok: true, data: { builder: { id: 95, github_login: 'jaxri', rank: 'metic' }, shipped_count: 4, achievements: [], recent_ships: [] } };
-      }
-      if (url.includes('/activity?')) {
-        const isGoals = url.includes('section=goals');
-        return { status: 200, ok: true, data: { rows: isGoals ? [{ id: 7, title: 'A goal', disciplines: ['artist'], task_shipped: 1, task_total: 2 }] : [{ id: 42, title: 'A work', discipline: 'engineer', shipped_at: '2026-08-01T00:00:00Z' }], total: 1 } };
-      }
-      if (url.includes('/inbox/by-builder/')) {
-        return { status: 200, ok: true, data: { ideas: TRAIL, total: TRAIL.length } };
-      }
-      return { status: 404, ok: false, data: null };
-    },
-  };
-
-  // The captured ledgers, keyed by the mount element they were given.
-  const ledgers = new Map();
-  let tabsOnChange = null;
-  const kit = {
-    makePager: (prefix, key, opts = {}) => ({
-      prefix, key, page: 1, perPage: opts.defaultPerPage || 25,
-      perPageOptions: [10, 25], minPerPage: opts.minPerPage ?? 10,
-    }),
-    pageOffset: (p) => Math.max(0, (p.page - 1) * p.perPage),
-    makeLedger: ({ mount, rowHtml }) => {
-      const rec = { rows: [], total: 0, html: '' };
-      const ledger = {
-        render(rows, opts = {}) {
-          rec.rows = rows || [];
-          rec.total = opts.total || 0;
-          rec.html = rec.rows.map((r, i) => rowHtml(r, i)).join('');
-        },
-      };
-      ledgers.set(mount, rec);
-      return ledger;
-    },
-    makeTabs: ({ tabs, onChange }) => {
-      let current = tabs[0].id;
-      tabsOnChange = onChange;
-      onChange(current);
-      return { active: () => current, activate(id) { current = id; onChange(id); } };
-    },
-    shipVisualThumbHtml: () => '',
-  };
-
-  const windowObj = {
-    __BRANDING__: {}, __MODULES__: { enabled: {} },
-    BongosClient: { createClient: () => client },
-    OTBKit: kit,
-    OTB: {
-      // task 1003936 — the role axis vocabulary (dom-utils OTB.role*). PRESENT for
-      // the same reason categoryChip is: an undefined helper throws mid-render.
-      roleAxisLabel: () => 'Role',
-      roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
-      roleIsUnset: (d) => !d || d === 'unclassified',
-      ROLE_UNSET: 'unclassified',
-      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
-      $: (sel) => documentObj.querySelector(sel),
-      fmtNum: (n) => String(n ?? 0),
-      fmtDate: (iso) => String(iso ?? '').slice(0, 10),
-      rankLabel: (r) => r,
-      toast() {},
-    },
-    location: { hostname: 'builders.cloudbongos.com', search: '', pathname: '/profile' },
-    localStorage: { getItem: () => null, setItem() {} },
-    addEventListener() {},
-  };
-
-  const sandbox = {
-    window: windowObj, document: documentObj, location: windowObj.location,
-    console, setTimeout, clearTimeout, URLSearchParams,
-  };
-  sandbox.globalThis = sandbox;
-  vm.createContext(sandbox);
-  vm.runInContext(PROFILE_JS, sandbox, { filename: 'profile.js' });
-
-  const htmlFor = (mountId) => {
-    const rec = ledgers.get(documentObj.getElementById(mountId));
-    return rec ? rec.html : null;
-  };
-  return {
-    requests,
-    htmlFor,
-    switchCraft: (id) => { if (tabsOnChange) tabsOnChange(id); },
-    el: (id) => documentObj.getElementById(id),
-  };
-}
 
-const settle = () => new Promise((r) => setTimeout(r, 0));
 
 await test('the ideator view shows EVERY idea filed, whatever became of it', async () => {
   const p = bootProfile();