@bongos/core 1.19.971 → 1.19.973

package/tests/hall_mine_lens.mjs

@@ -0,0 +1,381 @@
+// tests/hall_mine_lens.mjs — the hall's "Only mine" lens: goals you are added
+// on, and tasks you have claimed.
+//
+// The lens is ONE checkbox that four tabs answer differently — Ready and Backlog
+// by goal membership, In Progress by who holds the claim, Completed by who
+// shipped it. That is exactly the shape a source-grep test cannot prove: a regex
+// can see that `mineOn()` is called and still miss that a renderer filters the
+// wrong list, or counts the unfiltered one, or silently empties every tab when
+// the membership read fails. So work.js is BOOTED here, against the stub DOM
+// tests/helpers.mjs already uses for the profile and idea pages, and the
+// assertions read the HTML the page actually wrote.
+//
+// Each test below was verified by deleting the line it guards and watching it go
+// red — the vacuous-guard check this suite has been bitten by before.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { settle } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const WORK_JS = fs.readFileSync(path.join(HALL, 'work.js'), 'utf8');
+// The two files work.js was carved into. Run the REAL ones rather than stubbing
+// them: mine-lens.js IS the subject here, and work-summary.js is the piece that
+// left work.js to make room for it — a stub of either would let the carve rot.
+const MINE_LENS_JS = fs.readFileSync(path.join(HALL, 'mine-lens.js'), 'utf8');
+const WORK_SUMMARY_JS = fs.readFileSync(path.join(HALL, 'work-summary.js'), 'utf8');
+
+// ---------------------------------------------------------------------------
+// The fixture. Two goals, and the viewer (builder 7, @percy) is on ONE of them.
+// Every list below is built so that "mine" and "not mine" are both non-empty —
+// a lens that returned everything and a lens that returned nothing would both
+// pass against a one-sided fixture.
+// ---------------------------------------------------------------------------
+const MINE_GOAL = 1000101;
+const THEIRS_GOAL = 1000102;
+
+const GOALS = [
+  { id: MINE_GOAL, title: 'A goal I am on', viewer_is_member: true },
+  { id: THEIRS_GOAL, title: 'A goal I am not on', viewer_is_member: false },
+];
+
+const CLAIMABLE = [
+  { id: 501, title: 'ready in my goal', goal_id: MINE_GOAL, status: 'ready', version_id: 'V1' },
+  { id: 502, title: 'ready in their goal', goal_id: THEIRS_GOAL, status: 'ready', version_id: 'V1' },
+  // A task with NO goal at all. It is nobody's by membership, and it exists in
+  // the fixture to pin that the lens excludes it rather than letting the
+  // ungoaled backlog ride along under the word "mine".
+  { id: 503, title: 'ready with no goal', goal_id: null, status: 'ready', version_id: 'V1' },
+];
+
+const BACKLOG = [
+  { id: 601, title: 'backlog in my goal', goal_id: MINE_GOAL, status: 'backlog', version_id: 'V1' },
+  { id: 602, title: 'backlog in their goal', goal_id: THEIRS_GOAL, status: 'backlog', version_id: 'V1' },
+];
+
+const ACTIVE_CLAIMS = [
+  { claim_id: 9001, task_id: 701, title: 'a claim of mine', builder_id: 7, github_login: 'percy', display_name: 'Percy', claimed_at: '2026-09-20T00:00:00Z' },
+  { claim_id: 9002, task_id: 702, title: 'someone else holds this', builder_id: 8, github_login: 'annabeth', display_name: 'Annabeth', claimed_at: '2026-09-20T00:00:00Z' },
+];
+
+const SHIPPED = [
+  { id: 801, title: 'I shipped this', github_login: 'percy', shipped_at: '2026-09-21T00:00:00Z' },
+  { id: 802, title: 'they shipped this', github_login: 'annabeth', shipped_at: '2026-09-21T00:00:00Z' },
+];
+
+// ---------------------------------------------------------------------------
+// bootWorkBoard — run the REAL work.js in a vm.
+//
+// `goalsFail: true` makes GET /goals reject, which is the failure mode the lens
+// has to survive honestly: with no membership evidence it must switch itself off
+// rather than narrow both queue tabs to nothing.
+// ---------------------------------------------------------------------------
+function bootWorkBoard({ signedIn = true, goalsFail = false } = {}) {
+  const els = new Map();
+  const makeEl = (id = '') => ({
+    id,
+    dataset: {}, style: {}, textContent: '', hidden: false, disabled: false,
+    checked: false, value: '', title: '',
+    _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; },
+    listeners: {},
+    addEventListener(type, fn) { (this.listeners[type] ||= []).push(fn); },
+    fire(type, ev = {}) { (this.listeners[type] || []).forEach((fn) => fn(ev)); },
+    querySelector() { return null; }, querySelectorAll() { return []; },
+    appendChild() {}, remove() {}, closest() { return null; },
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  // Keyed by the selector text with the leading '#' stripped, so a compound
+  // selector like '#wip-table tbody' gets its own stable element — which is
+  // what work.js reads the in-flight rows out of.
+  const el = (key) => { if (!els.has(key)) els.set(key, makeEl(key)); return els.get(key); };
+  const documentObj = {
+    getElementById: (id) => el(id),
+    querySelector: (sel) => el(String(sel).replace(/^#/, '')),
+    querySelectorAll: () => [],
+    createElement: () => makeEl(),
+    addEventListener(type, fn) { (this.listeners[type] ||= []).push(fn); },
+    listeners: {},
+    body: { dataset: {} }, documentElement: { dataset: {} },
+    hidden: false,
+  };
+
+  const requests = [];
+  const client = {
+    request: async (method, url) => {
+      requests.push(`${method} ${url}`);
+      const ok = (data) => ({ status: 200, ok: true, data });
+      if (url.endsWith('/me')) {
+        // `signedIn: false` is a 200 that carries NO builder, not a 401: a 401
+        // bounces this page to sign-in before anything renders (and the server
+        // page gate bars an unauthenticated visitor from /work outright), so the
+        // identity-less state the lens actually has to survive is this one.
+        return signedIn
+          ? ok({ builder: { id: 7, display_name: 'Percy', github_login: 'percy', rank: 'metic' }, task_kinds: ['build'] })
+          : ok({ builder: null });
+      }
+      if (url.endsWith('/goals')) {
+        return goalsFail ? { status: 500, ok: false, data: null } : ok({ goals: GOALS });
+      }
+      if (url.includes('/tasks/claimable')) return ok({ claimable: CLAIMABLE, active_claims: ACTIVE_CLAIMS });
+      if (url.includes('/tasks?status=backlog')) return ok({ tasks: BACKLOG });
+      if (url.includes('/public/recent-shipped')) return ok({ tasks: SHIPPED });
+      if (url.includes('/versions')) return ok({ versions: [{ version_id: 'V1' }] });
+      if (url.includes('/public/progress')) return ok({ progress: [{ version_id: 'V1', lifecycle_shipped_count: 42 }] });
+      if (url.includes('/public/cost-summary')) return ok({ total_value_credits: 1234 });
+      return ok({});
+    },
+  };
+
+  const escapeHtml = (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  let tabsOnChange = null;
+  const kit = {
+    makePager: (prefix) => ({ prefix, page: 1, perPage: 100 }),
+    paginate: (rows) => rows,
+    wirePager() {},
+    pagerBarHtml: () => '',
+    makeTabs: ({ tabs, onChange }) => {
+      let current = tabs[0].id;
+      tabsOnChange = onChange;
+      return { active: () => current, setCount() {}, activate(id) { current = id; onChange(id); } };
+    },
+    // The real bar is hall-kit's; here it only has to MAKE the controls readable,
+    // because what this suite asserts is what the renderers do with their values.
+    makeFilterBar: ({ search, primary = [], overflow = [] }) => {
+      [search, ...primary, ...overflow].filter(Boolean).forEach((c) => {
+        el(c.id).value = c.value ?? c.default ?? '';
+      });
+      return { values: () => ({}), get: () => '', set() {} };
+    },
+    ageChipHtml: () => '',
+  };
+
+  const windowObj = {
+    __BRANDING__: { currency: { label: 'credits' } },
+    BongosClient: { createClient: () => client },
+    OTBKit: kit,
+    OTBTaskDetail: { href: (id) => `/task/${id}`, open() {} },
+    OTBTaskLib: {
+      priorityRank: () => 0, touchesConflict: () => false, rankTagHtml: () => '',
+      creditsPerMinute: () => 0, buildPromptForTask: () => '', friendlyBatchReason: () => '',
+      taskActivityMs: () => 0, STALE_CHOICES: [{ value: '', label: '— any —' }], isStale: () => false,
+    },
+    OTB: {
+      escapeHtml,
+      $: (sel) => documentObj.querySelector(sel),
+      fmtNum: (n) => String(n ?? 0),
+      fmtDate: (d) => String(d ?? '').slice(0, 10),
+      errCode: () => null, errDetails: () => ({}),
+      toast() {},
+      categoryChip: () => '',
+      fillKindFilter() {},
+      kindIsUnset: () => true, KIND_UNSET: 'unclassified',
+      roleAxisLabel: () => 'Role',
+      roleOptions: () => [{ value: '', label: '— any —' }],
+      roleIsUnset: () => true, roleLabel: () => '', ROLE_UNSET: 'unclassified',
+    },
+    location: { hostname: 'builders.example.com', pathname: '/work', search: '', hash: '', href: 'https://builders.example.com/work' },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    confirm: () => true,
+    addEventListener() {},
+  };
+
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    localStorage: windowObj.localStorage, console, setTimeout, clearTimeout,
+    setInterval: () => 0, clearInterval() {}, Date, URL, URLSearchParams, navigator: {},
+    history: { replaceState() {} },
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  // Both are UMD modules that attach to the sandbox global rather than to
+  // `window` (there is no `module` here), so they are bridged across by hand.
+  vm.runInContext(MINE_LENS_JS, sandbox, { filename: 'mine-lens.js' });
+  vm.runInContext(WORK_SUMMARY_JS, sandbox, { filename: 'work-summary.js' });
+  windowObj.OTBMineLens = sandbox.OTBMineLens;
+  windowObj.OTBWorkSummary = sandbox.OTBWorkSummary;
+  vm.runInContext(WORK_JS, sandbox, { filename: 'work.js' });
+  (documentObj.listeners.DOMContentLoaded || []).forEach((fn) => fn());
+
+  return {
+    el,
+    requests,
+    // Flip the lens the way a click does: set the box, then fire its listener.
+    setMine: (on) => { el('f-mine').checked = on; el('f-mine').fire('change'); },
+    switchTab: (id) => { if (tabsOnChange) tabsOnChange(id); },
+  };
+}
+
+// settle() twice: loadAll awaits /me, then the goals read, then the claimable
+// read, and the history feed lands on its own promise chain.
+const ready = async (board) => { for (let i = 0; i < 6; i += 1) await settle(); return board; };
+
+// ---------------------------------------------------------------------------
+// 1. The queue tabs: "mine" is GOAL MEMBERSHIP
+// ---------------------------------------------------------------------------
+
+test('Ready narrows to tasks in a goal the viewer is a member of', async () => {
+  const b = await ready(bootWorkBoard());
+  const before = b.el('task-list').innerHTML;
+  assert.match(before, /ready in my goal/, 'the unfiltered board shows both goals');
+  assert.match(before, /ready in their goal/);
+
+  b.setMine(true);
+  const after = b.el('task-list').innerHTML;
+  assert.match(after, /ready in my goal/, 'the task in my goal survives');
+  assert.doesNotMatch(after, /ready in their goal/, 'the task in a goal I am not on is gone');
+});
+
+test('a task with NO goal is not "mine" — the lens is membership, not leftovers', async () => {
+  const b = await ready(bootWorkBoard());
+  assert.match(b.el('task-list').innerHTML, /ready with no goal/, 'it is there unfiltered');
+  b.setMine(true);
+  assert.doesNotMatch(b.el('task-list').innerHTML, /ready with no goal/,
+    'an ungoaled task belongs to nobody, so it cannot arrive under "only mine"');
+});
+
+test('Backlog narrows through the SAME predicate, so the lens cannot reach one tab only', async () => {
+  const b = await ready(bootWorkBoard());
+  assert.match(b.el('backlog-list').innerHTML, /backlog in their goal/);
+  b.setMine(true);
+  assert.match(b.el('backlog-list').innerHTML, /backlog in my goal/);
+  assert.doesNotMatch(b.el('backlog-list').innerHTML, /backlog in their goal/);
+});
+
+// ---------------------------------------------------------------------------
+// 2. In Progress: "mine" is THE CLAIM
+// ---------------------------------------------------------------------------
+
+test('In Progress narrows to the claims the viewer is holding', async () => {
+  const b = await ready(bootWorkBoard());
+  const tbody = b.el('wip-table tbody');
+  assert.match(tbody.innerHTML, /someone else holds this/, 'unfiltered, the whole board is in flight');
+
+  b.setMine(true);
+  assert.match(tbody.innerHTML, /a claim of mine/);
+  assert.doesNotMatch(tbody.innerHTML, /someone else holds this/,
+    "another builder's live claim is not mine");
+});
+
+test('the in-flight SECTION pill counts what is shown; the TAB pill keeps the whole board', async () => {
+  // The distinction is the point: narrowing to my own claims must not make the
+  // board look idle. The tab pill is the project's in-flight count either way.
+  const b = await ready(bootWorkBoard());
+  assert.equal(b.el('wip-count').textContent, '2');
+  b.setMine(true);
+  assert.equal(b.el('wip-count').textContent, '1', 'the section pill follows the narrowed list');
+});
+
+test('holding nothing says so, instead of reading as a quiet board', async () => {
+  const b = await ready(bootWorkBoard());
+  // Hand the page an in-flight list with none of the viewer's own claims by
+  // flipping the lens on a fixture where builder 7 holds one — then assert the
+  // OTHER direction: a viewer who holds nothing gets the specific sentence.
+  ACTIVE_CLAIMS[0].builder_id = 8;
+  try {
+    b.setMine(true);
+    assert.match(b.el('wip-table tbody').innerHTML, /You are not holding any claims right now/,
+      'the empty state names the lens, not the project');
+  } finally {
+    ACTIVE_CLAIMS[0].builder_id = 7;
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 3. Completed: "mine" is WHO SHIPPED IT
+// ---------------------------------------------------------------------------
+
+test('Completed narrows to the viewer\'s own ships, matched on the login the public feed carries', async () => {
+  const b = await ready(bootWorkBoard());
+  assert.match(b.el('history-list').innerHTML, /they shipped this/);
+  b.setMine(true);
+  assert.match(b.el('history-list').innerHTML, /I shipped this/);
+  assert.doesNotMatch(b.el('history-list').innerHTML, /they shipped this/);
+});
+
+// ---------------------------------------------------------------------------
+// 4. The two ways the lens must refuse rather than lie
+// ---------------------------------------------------------------------------
+
+test('with no identity the lens is disabled — never a checkbox that empties every tab', async () => {
+  const b = await ready(bootWorkBoard({ signedIn: false }));
+  assert.equal(b.el('f-mine').disabled, true);
+  assert.equal(b.el('f-mine').checked, false);
+  assert.match(b.el('f-mine').title, /Sign in/);
+});
+
+test('a failed membership read disarms the lens instead of answering "you are on no goals"', async () => {
+  const b = await ready(bootWorkBoard({ goalsFail: true }));
+  assert.equal(b.el('f-mine').disabled, true,
+    'with no evidence the lens is off the table');
+  assert.match(b.el('f-mine').title, /could not be loaded/,
+    'and it says the read failed rather than implying an answer');
+  // The board itself is untouched — losing the lens must not lose the queue.
+  assert.match(b.el('task-list').innerHTML, /ready in their goal/);
+});
+
+// ---------------------------------------------------------------------------
+// 5. The word means something different on each tab, so the hint is rewritten
+// ---------------------------------------------------------------------------
+
+test('the hint beside the checkbox is re-read from the tab, not left generic', async () => {
+  const b = await ready(bootWorkBoard());
+  const hint = b.el('work-mine-hint');
+  assert.equal(hint.textContent, 'tasks in goals you are on', 'Ready opens the board');
+  b.switchTab('in-progress');
+  assert.equal(hint.textContent, 'claims you are holding');
+  b.switchTab('completed');
+  assert.equal(hint.textContent, 'tasks you shipped');
+  b.switchTab('backlog');
+  assert.equal(hint.textContent, 'tasks in goals you are on');
+});
+
+// ---------------------------------------------------------------------------
+// 6. It costs nothing to ask
+// ---------------------------------------------------------------------------
+
+test('the lens is answered from data the board already fetched — no read per goal', async () => {
+  const b = await ready(bootWorkBoard());
+  const before = b.requests.length;
+  b.setMine(true);
+  assert.equal(b.requests.length, before,
+    'flipping the lens makes no request: viewer_is_member rides the goal list');
+  assert.ok(b.requests.some((r) => r.endsWith('/goals')),
+    'and the goal list is the one read it depends on');
+  assert.ok(!b.requests.some((r) => /\/goals\/\d+\/members/.test(r)),
+    'never a membership read per goal');
+});
+
+// ---------------------------------------------------------------------------
+// 7. The carve: work-summary.js
+//
+// The momentum card left work.js so the lens could fit under the size ceiling.
+// Two things have to stay true across that move — it still paints, and it still
+// reports the PROJECT, not the viewer. The second is the risk the carve created:
+// the card sits directly above a list the lens narrows, and a card that quietly
+// restated one builder's output as the project's totals would look right.
+// ---------------------------------------------------------------------------
+
+test('the momentum card still renders the project-wide figures after the carve', async () => {
+  const b = await ready(bootWorkBoard());
+  const card = b.el('works-summary');
+  assert.equal(card.hidden, false, 'the card is shown once the shipped counts land');
+  assert.match(card.innerHTML, /Works shipped/);
+  assert.match(card.innerHTML, /42/, 'the all-time shipped count');
+  assert.match(card.innerHTML, /1234/, 'and the credits awarded');
+});
+
+test('"Only mine" does NOT narrow the project totals above the list it narrows', async () => {
+  const b = await ready(bootWorkBoard());
+  const before = b.el('works-summary').innerHTML;
+  b.setMine(true);
+  assert.equal(b.el('works-summary').innerHTML, before,
+    'the card reports the project; the lens reports the reader');
+});

package/tests/idea_spark_hall.mjs

@@ -65,6 +65,15 @@ function boot({
   // `{ outcome: null }`, which is the server saying "nothing to state yet"; the
   // line must go quiet for both, and there is a case below for each.
   landing = undefined,
+  // OUT-OF-ORDER READS (task 1004108). Names of fakes whose answers are PARKED
+  // instead of returned: the call is recorded and its response computed at once,
+  // but the caller's `await` does not resolve until the test releases it. That is
+  // the only way two reads of the same endpoint are ever in flight together here
+  // — every other fake is an `async` function that settles before the next call
+  // is made, so a monotonic-sequence guard sits on an unreachable branch and
+  // deleting it reds nothing. Pass e.g. `defer: ['preview']` and drive
+  // `r.deferred` in whatever order the race being pinned requires.
+  defer = [],
 } = {}) {
   const els = new Map();
   const makeEl = () => ({
@@ -88,6 +97,21 @@ function boot({
   };
 
   const calls = [];
+
+  // Parked calls, in REQUEST order. Each carries the name it was made under, the
+  // arguments it was made with, and `release()` — which hands the caller the
+  // answer the fake had already computed. Releasing out of order is the point.
+  const deferred = [];
+  const deferSet = new Set(defer);
+  const gate = (name, fn) => (...args) => {
+    const answer = fn(...args); // record the call and compute the reply NOW...
+    if (!deferSet.has(name)) return answer;
+    let release;
+    const held = new Promise((resolve) => { release = resolve; });
+    deferred.push({ name, args, release: () => release(answer) }); // ...hand it over LATER
+    return held;
+  };
+
   const client = {
     inbox: {
       getInboxTemplate: async () => ({ status: 200, ok: true, data: { template: TEMPLATE } }),
@@ -117,7 +141,7 @@ function boot({
       // real matrix for the fixtures this file already files with: a goal named
       // ⇒ it lands there, no goal ⇒ it floats. A test that cares about a
       // particular verdict passes `landing` and overrides the lot.
-      postInboxPreviewLanding: async (a) => {
+      postInboxPreviewLanding: gate('preview', async (a) => {
         calls.push(['preview', a]);
         if (landing === null) return { status: 500, ok: false, data: null };
         if (landing !== undefined) return { status: 200, ok: true, data: landing };
@@ -127,7 +151,7 @@ function boot({
           return { status: 200, ok: true, data: { outcome: 'routed', reason: 'bug_trusted_filer', status: 'ready', goal: { id: String(gid), title: g ? g.title : `goal ${gid}` }, version_id: 'BV1', refusal: null } };
         }
         return { status: 200, ok: true, data: { outcome: 'floats', reason: 'no_goal', status: null, goal: null, version_id: null, refusal: null } };
-      },
+      }),
     },
     // task 1003069 (R08) — the quick-filing goal picker's reads: the building
     // versions (to scope the suggester) and the open goal list (the picker's
@@ -137,7 +161,7 @@ function boot({
     },
     goals: {
       getGoals: async () => { calls.push(['goals', null]); return { status: 200, ok: true, data: { goals } }; },
-      getGoalsSuggestions: async (a) => { calls.push(['suggest', a]); return { status: 200, ok: true, data: { suggestions } }; },
+      getGoalsSuggestions: gate('suggest', async (a) => { calls.push(['suggest', a]); return { status: 200, ok: true, data: { suggestions } }; }),
     },
   };
 
@@ -173,7 +197,7 @@ function boot({
 
   const el = (id) => documentObj.getElementById(id);
   return {
-    calls, toasts, store, el,
+    calls, toasts, store, el, deferred,
     queueHtml: () => el('fi-queue').innerHTML,
     fill: () => { for (const f of TEMPLATE.fields) el(`fi-f-${f.key}`).value = `an answer for ${f.key} long enough to count`; },
     submit: () => el('fi-form')._handlers.submit({ preventDefault() {} }),
@@ -678,11 +702,67 @@ await test('filing clears the line — gravity describes a draft, and the draft
   assert.equal(r.el('fq-receipts').hidden, false, 'the RECEIPT is what survives instead (task 1004082)');
 });
 
+// --- out-of-order reads (task 1004108) -----------------------------------
+//
+// Everything above this line drives fakes that settle before the next call is
+// made, so `refreshGravity`'s monotonic `gravitySeq` guard sat on a branch no
+// case could reach: deleting it redded NOTHING, which the closing note below
+// used to record as an honest gap. `boot({ defer: [...] })` parks a named fake's
+// answer until the test hands it back, so two reads are genuinely in flight at
+// once and the slower one can land last.
+
+await test('two previews are genuinely in flight at once — the harness can interleave them', async () => {
+  // The non-vacuity guard for the case beneath it. If `defer` ever stopped
+  // parking, the race case below would still pass — it would just be testing two
+  // sequential reads again, which is the exact hole this pair exists to close.
+  const r = boot({ defer: ['preview'] });
+  await settle(); await settle();
+  r.el('fq-title').value = 'a loose thought';
+  r.el('fq-goal')._handlers.change();
+  await settle(); await settle();
+  assert.equal(r.deferred.length, 1, 'the first read is parked, not answered');
+  assert.equal(r.el('fq-gravity').textContent, '', 'and nothing is painted while it is in flight');
+  r.el('fq-goal').value = '77';
+  r.el('fq-goal')._handlers.change();
+  await settle(); await settle();
+  assert.equal(r.deferred.length, 2, 'the second read starts while the first is still unanswered');
+  assert.deepEqual(r.deferred.map((d) => d.name), ['preview', 'preview']);
+});
+
+await test('a slow preview answering after a faster one never repaints the stale verdict', async () => {
+  // The race a builder hits by picking a goal and then changing their mind
+  // faster than the server answers. The FIRST request (no goal ⇒ "floats") comes
+  // back LAST; the line must keep the SECOND request's verdict.
+  const r = boot({ defer: ['preview'] });
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-goal').value = '';
+  r.el('fq-goal')._handlers.change();
+  await settle();
+  r.el('fq-goal').value = '77';
+  r.el('fq-goal')._handlers.change();
+  await settle();
+  assert.equal(r.deferred.length, 2, 'both reads are in flight');
+  assert.equal(r.deferred[0].args[0].body.goal_id, undefined, 'the first asked with no goal');
+  assert.equal(r.deferred[1].args[0].body.goal_id, 77, 'the second asked with the goal picked');
+
+  r.deferred[1].release(); // the NEWER answer lands first
+  await settle(); await settle();
+  assert.match(r.el('fq-gravity').textContent, /Goal Seventy Seven/, 'the current verdict paints');
+
+  r.deferred[0].release(); // and now the older, slower one arrives
+  await settle(); await settle();
+  assert.match(r.el('fq-gravity').textContent, /Goal Seventy Seven/, 'the stale answer does not repaint the line');
+  assert.doesNotMatch(r.el('fq-gravity').textContent, /floats in the inbox/, 'the superseded verdict never reaches the builder');
+  assert.equal(r.el('fq-gravity').dataset.tone, 'lands');
+});
+
 // Every guard above was reverted and each redded its named case (RUN, and these
 // are the measured counts, not the predicted ones):
 //   drop renderGravity from the goal-change handler   -> 2 red (named-goal + filing-clears)
 //   infer from the select instead of the verdict      -> 4 red (both lies, + backlog + refusal)
-//   drop the seq guard and paint every answer         -> 0 red  <-- see below
+//   drop the seq guard and paint every answer         -> 1 red (the race case; task 1004108)
+//   make boot's `defer` never park (gate returns at once) -> 2 red (both race cases)
 //   rename the id in ideas.html                       -> 1 red (the markup pin ONLY)
 //
 // THE FIRST LINE COST A TEST FIX, and it is the reason to run these rather than
@@ -692,13 +772,22 @@ await test('filing clears the line — gravity describes a draft, and the draft
 // rendered at all. It asserts on the TEXT now. A stub's defaults can agree with
 // a broken page, which is the same lesson the markup pin below teaches twice.
 //
-// THE THIRD LINE IS AN HONEST GAP, recorded rather than papered over. The
-// out-of-order guard in refreshGravity is not covered: the fake resolves
-// synchronously, so two previews cannot interleave here and a test that removed
-// the guard would still pass. Pinning it needs a fake that delays per call,
-// which is a different harness from this one. Filed as task 1004108 rather than
-// claimed as tested — a green test over an unreachable branch would be a false
-// claim of coverage, which is the failure this file's own note above warns about.
+// THE THIRD LINE WAS AN HONEST GAP UNTIL TASK 1004108, and the shape of the fix
+// is worth keeping: the guard was not wrong, it was UNREACHABLE. Every fake here
+// was an `async` function that settled before the next call was made, so two
+// previews could never overlap and deleting `if (seq !== gravitySeq) return;`
+// redded nothing — a green suite over a branch no case could enter. `boot({
+// defer: ['preview'] })` parks a named fake's answer until the test hands it
+// back, which makes the overlap real and the guard a tested property. The FOURTH
+// line above is the guard on the guard: if `defer` ever stops parking, the race
+// case would quietly go back to testing two sequential reads, so a case asserts
+// that both calls are in flight before the ordering is asserted at all.
+//
+// `getGoalsSuggestions` is gated the same way and for the same reason, but has
+// NO case yet: `refreshGoalSuggestions` carries no sequence guard — only
+// `goalTouchedByUser` — so a test of its ordering would red against the current
+// page rather than pin it. That is a production bug to file, not a test to
+// write, and the harness is now able to reach it the day it is fixed.
 
 console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);

package/tests/known_failing_ratchet.mjs

@@ -38,16 +38,26 @@ const TESTS_DIR = path.dirname(fileURLToPath(import.meta.url));
 // right all along. The apex flip removed the redirect, so the test passes and
 // the entry had to go in the same change — this file fails the suite the moment
 // a parked test starts passing.
-const MAX_KNOWN_FAILING = 1;
+//
+// Ratcheted down 1 → 0 by task 1002617, which unparked served_paths_shipped — the last
+// entry. Its own note here had PREDICTED the resolution ("whoever lands that claim should
+// re-check this assertion and remove this entry"); the claim landed (task 1002200, the
+// self-healing /docs/openapi.json endpoint) and the entry outlived it by months. That is
+// the graveyard this file exists to prevent, and it took this ratchet going red to close
+// the loop — which is the ratchet working, just later than it should have.
+//
+// AT ZERO, this file now asserts something stronger than a cap: that NOTHING is parked.
+// Parking the next failure means raising this number in the same diff, which is exactly
+// the deliberate, reviewable act it is meant to be.
+const MAX_KNOWN_FAILING = 0;
 
-const KNOWN_FAILING = {
-  served_paths_shipped: {
-    owner: 'task 1002617; collides with the ACTIVE claim "make the /docs/openapi.json endpoint self-healing"',
-    why: 'Asserts serve-internal.js reads docs/api/openapi.json. That exact path is what '
-       + 'the in-flight claim is changing, so touching it here would collide. Whoever lands '
-       + 'that claim should re-check this assertion and remove this entry.',
-  },
-};
+// EMPTY — nothing is parked, and that is the intended steady state.
+//
+// An entry here is invisible coverage: the test still runs, but its failure is expected,
+// so nobody looks at it. The last one sat for months while the very change it was waiting
+// on had already landed. If you add one, give it an owner and a concrete condition for
+// removal, and raise MAX_KNOWN_FAILING in the same diff.
+const KNOWN_FAILING = {};
 
 function runsRed(name) {
   try {

package/tests/landing_legal_pages.mjs

@@ -103,7 +103,11 @@ test('the landing page and the hub footers link privacy, terms and contact', ()
     for (const href of ['/privacy', '/terms', '/contact']) {
       assert.match(foot, new RegExp(`<a href="${href}">`), `${file}: footer links ${href}`);
     }
-    assert.match(foot, /Open source \(AGPL-3\.0\)/, `${file}: the licence link stays`);
+    // task 1003920 split one link into two: the WORDS now open the published code and the licence
+    // sits behind its own link beside it, so the claim can be checked by whoever clicks it. Both
+    // halves are asserted — a bare /Open source/ would pass again the moment the licence link went.
+    assert.match(foot, /<a href="https:\/\/www\.npmjs\.com\/package\/@bongos\/core"[^>]*>Open source<\/a>/, `${file}: the words open the actual code`);
+    assert.match(foot, /<a href="https:\/\/www\.gnu\.org\/licenses\/agpl-3\.0\.html"[^>]*>AGPL-3\.0<\/a>/, `${file}: the licence link stays`);
     assert.match(foot, /Built by agents/, `${file}: the attribution half stays`);
   }
 });

package/tests/projects_hub_pre_uat.mjs

@@ -474,16 +474,22 @@ test('decision 9 — only mouse-driven focus on a wizard heading goes ringless',
 });
 
 test('decision 10 — both footers carry the open-source (AGPL-3.0) link, in link ink', () => {
-  const AGPL = /<a href="https:\/\/www\.gnu\.org\/licenses\/agpl-3\.0\.html" target="_blank" rel="noopener">Open source \(AGPL-3\.0\)<\/a>\./;
+  // task 1003920 split this into TWO links: the words "Open source" open the published package and
+  // the licence sits behind its own link beside it. Both are asserted, and CODE is anchored first
+  // because it is the half 1003920 added and the half nothing else in the repo pins.
+  const CODE = /<a href="https:\/\/www\.npmjs\.com\/package\/@bongos\/core" target="_blank" rel="noopener">Open source<\/a>/;
+  const AGPL = /\(<a href="https:\/\/www\.gnu\.org\/licenses\/agpl-3\.0\.html" target="_blank" rel="noopener">AGPL-3\.0<\/a>\)\./;
   const hubFoot = (HUB.match(/<footer class="foot">[\s\S]*?<\/footer>/) || [''])[0];
   // task 1003298: the chrome-world landing's footer is a real <footer>; the
   // pre-world page used <div class="foot">. Either element is the footer.
   const indexFoot = (INDEX.match(/<footer(?:\s[^>]*)?>[\s\S]*?<\/footer>|<div class="foot">[\s\S]*?<\/div>/) || [''])[0];
-  assert.match(hubFoot, AGPL, 'projects.html');
-  assert.match(indexFoot, AGPL, 'index.html');
-  // the link sits OUTSIDE the apex-only span, so a child instance keeps it too
-  assert.ok(hubFoot.indexOf('<!--apex-only:end-->') < hubFoot.search(AGPL), 'projects.html: after the apex-only block');
-  assert.ok(indexFoot.indexOf('<!--apex-only:end-->') < indexFoot.search(AGPL), 'index.html: after the apex-only block');
+  assert.match(hubFoot, CODE, 'projects.html: the words open the actual code');
+  assert.match(indexFoot, CODE, 'index.html: the words open the actual code');
+  assert.match(hubFoot, AGPL, 'projects.html: the licence sits beside it');
+  assert.match(indexFoot, AGPL, 'index.html: the licence sits beside it');
+  // both links sit OUTSIDE the apex-only span, so a child instance keeps them too
+  assert.ok(hubFoot.indexOf('<!--apex-only:end-->') < hubFoot.search(CODE), 'projects.html: after the apex-only block');
+  assert.ok(indexFoot.indexOf('<!--apex-only:end-->') < indexFoot.search(CODE), 'index.html: after the apex-only block');
   assert.match(COSMOS, /\.foot a\{color:var\(--link-ink\);font-weight:700;text-decoration:none;\}/, 'never the browser’s blue');
 });