@bongos/core 1.19.495 → 1.19.497

package/tests/discord_inbound.mjs

@@ -46,10 +46,27 @@ await t('deriveIdea: long first line is capped (≤200, ellipsis)', () => {
 
 // ---- recordInboundIdea (fakes) --------------------------------------------
 function makeDeps(over = {}) {
-  const calls = { capture: [], audit: [], persist: [] };
+  const calls = { capture: [], audit: [], persist: [], suggest: [], listVersions: 0 };
   const deps = {
     getBuilderByDiscordUserId: async () => (over.builder === undefined ? null : over.builder),
     captureIdea: async (a) => { calls.capture.push(a); if (over.captureThrows) throw new Error('db boom'); return { id: over.ideaId ?? 77 }; },
+    // task 1003068 (R12): the goal-suggest fake. Default: no confident match
+    // (null) — the ordinary case. `over.goal` supplies a match; `over.suggestThrows`
+    // simulates the suggester outage this vector must survive.
+    suggestGoalForCapture: async (draft) => {
+      calls.suggest.push(draft);
+      if (over.suggestThrows) throw new Error('suggest boom');
+      return over.goal === undefined ? null : over.goal;
+    },
+    // task 1003068 (R12): the suggested_version DEFAULT fallback — only
+    // consulted when no goal matched. Default: no versions at all (empty),
+    // so the ordinary fixture keeps the version hint null. `over.versions`
+    // supplies rows; `over.listVersionsThrows` simulates the lookup outage.
+    listVersions: async () => {
+      calls.listVersions += 1;
+      if (over.listVersionsThrows) throw new Error('versions boom');
+      return over.versions === undefined ? [] : over.versions;
+    },
     insertAuditLog: async (a) => { calls.audit.push(a); if (over.auditThrows) throw new Error('audit boom'); return { id: 1 }; },
     persistImages: async (urls, opts) => {
       calls.persist.push({ urls, opts });
@@ -88,6 +105,77 @@ await t('recordInboundIdea: never produces the rank-gated criterion-proposal kin
   assert.notEqual(calls.capture[0].kind, 'criterion-proposal');
 });
 
+// ---- goal/version routing HINTS (task 1003068, BV1.R12) -------------------
+await t('recordInboundIdea: a confident suggester match writes the HINT columns, never routes', async () => {
+  const { deps, calls } = makeDeps({
+    builder: { id: 9, github_login: 'mona' },
+    goal: { id: 42, title: 'The vendor rework', version_id: 'BONGOS-V1', score: 6 },
+  });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'Vendors should restock overnight', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(calls.capture[0].suggestedGoalId, 42, 'the suggested goal rides as the hint');
+  assert.equal(calls.capture[0].suggestedVersion, 'BONGOS-V1', "the goal's own version is the version hint");
+  // THE HARD RULE: goalId is never set, however confident the match — this
+  // vector suggests, it never routes (unlike discord-bugs.js). captureIdea
+  // would ROUTE (create a task) the moment goalId is non-null, so the absence
+  // of the key itself is the assertion, not just its value.
+  assert.equal('goalId' in calls.capture[0], false, 'goalId must never be passed — never route, never a task');
+  assert.equal(calls.listVersions, 0, "a matched goal's own version wins — the default lookup is never consulted");
+});
+
+await t('recordInboundIdea: no confident match, no building version → both hints null, still filed', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' }, goal: null });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'a vague thought', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(calls.capture[0].suggestedGoalId, null);
+  assert.equal(calls.capture[0].suggestedVersion, null);
+});
+
+await t('recordInboundIdea: no confident match → suggested_version DEFAULTS to the most-recently-started building version', async () => {
+  const { deps, calls } = makeDeps({
+    builder: { id: 9, github_login: 'mona' },
+    goal: null,
+    versions: [
+      { id: 'GDS-V3', status: 'shipped', started_at: '2026-01-01T00:00:00Z' },
+      { id: 'BONGOS-V1', status: 'building', started_at: '2026-06-01T00:00:00Z' },
+      { id: 'BONGOS-V2', status: 'building', started_at: '2026-08-15T00:00:00Z' },
+    ],
+  });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'a vague thought', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(calls.capture[0].suggestedGoalId, null, 'still no goal — nothing confident matched');
+  assert.equal(calls.capture[0].suggestedVersion, 'BONGOS-V2', 'the LATER-started building version wins, the shipped one is ignored');
+});
+
+await t('recordInboundIdea: suggester throws → filing still succeeds, hints null', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' }, suggestThrows: true });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'idea despite an outage', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'filed', 'a suggester outage costs the hint, never the idea');
+  assert.equal(calls.capture[0].suggestedGoalId, null);
+  assert.equal(calls.capture[0].suggestedVersion, null);
+  assert.equal('goalId' in calls.capture[0], false);
+});
+
+await t('recordInboundIdea: default-version lookup throws → filing still succeeds, version hint null', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' }, goal: null, listVersionsThrows: true });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'idea despite an outage', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'filed', 'a version-lookup outage costs the hint, never the idea');
+  assert.equal(calls.capture[0].suggestedVersion, null);
+});
+
+await t('mostRecentBuildingVersionId: pure — building-only, latest started_at, empty/absent → null', () => {
+  assert.equal(ib.mostRecentBuildingVersionId([]), null);
+  assert.equal(ib.mostRecentBuildingVersionId(undefined), null);
+  assert.equal(ib.mostRecentBuildingVersionId([{ id: 'A', status: 'planning', started_at: '2026-01-01' }]), null);
+  assert.equal(
+    ib.mostRecentBuildingVersionId([
+      { id: 'OLD', status: 'building', started_at: '2026-01-01' },
+      { id: 'NEW', status: 'building', started_at: '2026-06-01' },
+    ]),
+    'NEW'
+  );
+});
+
 await t('recordInboundIdea: empty content → ignored, nothing filed', async () => {
   const { deps, calls } = makeDeps();
   const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: '   ', messageId: 'm' }, deps);

package/tests/goal_advisory.mjs

@@ -55,10 +55,30 @@ await test('catch_all — landing in "<version> — general" is a bucket, not a
   assert.equal(a.goal_id, 3, 'names the catch-all so a caller can PATCH away from it');
 });
 
+// task 1003214 (idea 1000828): a bug in the catch-all is where it belongs, so the
+// advisory goes silent (reuses the same null the module already uses for "no
+// advice needed").
+await test("kind='bug' in the catch-all is quiet — a fix is where it belongs", () => {
+  assert.equal(adviseGoal({ versionId: V, goalId: 3, goalTitle: generalGoalTitle(V), kind: 'bug' }), null);
+});
+
+await test("kind='feature' in the catch-all still gets the nudge — quiet is bug-only", () => {
+  const a = adviseGoal({ versionId: V, goalId: 3, goalTitle: generalGoalTitle(V), kind: 'feature' });
+  assert.equal(a.reason, 'catch_all');
+});
+
+await test("kind='bug' with no goal at all is quiet too — a fix needs no home to be filed correctly", () => {
+  assert.equal(adviseGoal({ versionId: V, goalId: null, kind: 'bug' }), null);
+});
+
 await test('a REAL goal is silent — null, not an empty object', () => {
   assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, dev box, and skills' }), null);
 });
 
+await test("kind='bug' under a real goal is silent too — already silent, kind changes nothing", () => {
+  assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, dev box, and skills', kind: 'bug' }), null);
+});
+
 // The bug this guards: a near-miss title must not be mistaken for the catch-all.
 // db.generalGoalIdForVersion resolves the SAME string, so if these two ever disagree
 // a task would be filed into a goal the advisory then calls orphaned (or vice versa).
@@ -164,6 +184,14 @@ await test('buildGoalAdvisory: the catch-all is detected and named', async () =>
   assert.equal(a.goal_id, 3);
 });
 
+// task 1003214: the full POST /tasks path (buildGoalAdvisory reads task.kind
+// off the already-committed row) for a bug landed in the catch-all — silent.
+await test("buildGoalAdvisory: kind='bug' in the catch-all yields null end to end", async () => {
+  const db = stubDb({ goal: { id: 3, title: generalGoalTitle(V) }, goals: [] });
+  const a = await buildGoalAdvisory({ db, versionId: V, task: { id: 7, goal_id: 3, kind: 'bug' } });
+  assert.equal(a, null);
+});
+
 // The invariant a future refactor will quietly break. Both DB calls are covered:
 // getGoal is only reached when goal_id is set, listGoals only on the unhappy path.
 await test('NON-BLOCKING: buildGoalAdvisory returns null when getGoal throws', async () => {

package/tests/hall_record_world.mjs

@@ -269,8 +269,14 @@ const MD_SRC = read('md-reader.js');
 // grade / sessionLogs / claims (task 1003437): left undefined, the stub answers
 // like a client that never asked (the key is absent); null or an array answers
 // like the read did. `requests` records every path the page asked for.
-function renderTask(task, { lastClaim = null, viewer = null, goal = null, status = 200, search = '', referrer = '', withReader = true, grade, sessionLogs, claims } = {}) {
+// goalsList (task 1003063 / R10) feeds GET /goals?version= — the move-to-goal
+// picker's options. `patch` controls the response to PATCH /tasks/:id: null
+// (default) echoes the task back at 200 with goal_id applied from the request
+// body (so a reload's GET reflects the move); { status, data } refuses it with
+// that shape instead, for the refusal-surfacing tests.
+function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsList = null, patch = null, status = 200, search = '', referrer = '', withReader = true, grade, sessionLogs, claims } = {}) {
   const requests = [];
+  const toasts = [];
   const els = new Map();
   const makeEl = () => ({
     dataset: {}, style: {}, textContent: '', hidden: false, disabled: false, _html: '',
@@ -294,8 +300,18 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, status
     addEventListener(type, fn) { if (type === 'DOMContentLoaded') onReady = fn; },
   };
   const client = {
-    request: async (method, p) => {
+    request: async (method, p, opts) => {
       requests.push(p);
+      // PATCH must be checked before the generic /tasks/\d+ read below — both
+      // match the same path shape, and the read branch ignores method.
+      if (method === 'PATCH' && /\/tasks\/\d+$/.test(p)) {
+        if (patch && patch.status && patch.status !== 200) {
+          return { status: patch.status, ok: false, data: patch.data || null };
+        }
+        const body = (opts && opts.body) || {};
+        if (body.goal_id != null) task.goal_id = body.goal_id; // same object load() re-reads on reload
+        return { status: 200, ok: true, data: { task } };
+      }
       if (/\/tasks\/\d+/.test(p)) {
         if (status !== 200) return { status, ok: false, data: null };
         const data = { task, last_claim: lastClaim };
@@ -305,6 +321,7 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, status
         return { status: 200, ok: true, data };
       }
       if (/\/me$/.test(p)) return { status: 200, ok: true, data: { builder: viewer } };
+      if (/\/goals\?/.test(p)) return { status: 200, ok: true, data: { goals: goalsList || [] } };
       if (/\/goals\//.test(p)) return { status: 200, ok: true, data: { goal } };
       return { status: 404, ok: false, data: null };
     },
@@ -320,7 +337,7 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, status
       errCode: (d) => (d && d.error && d.error.code) || null,
       errMessage: (d) => (d && d.error && d.error.message) || null,
       categoryChip: () => '',
-      toast() {},
+      toast(msg) { toasts.push(String(msg)); },
     },
     location: { hostname: 'builders.cloudbongos.com', pathname: `/task/${task && task.id ? task.id : '1'}`, search, origin: 'https://builders.cloudbongos.com', assign() {} },
     addEventListener() {},
@@ -339,6 +356,7 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, status
     sub: () => documentObj.getElementById('task-sub').textContent,
     el: (id) => documentObj.getElementById(id),
     requests,
+    toasts,
   };
 }
 
@@ -750,3 +768,53 @@ test('the mocks no longer mark the two regions proposed — they are built', ()
     assert.ok(!mock.includes('<em>proposed</em>'), `${v}: no proposed eyebrow`);
   }
 });
+
+// ---- 11. the move-to-goal affordance (task 1003063 / R10) -------------------
+//
+// PATCH /tasks/:id {goal_id} (task 1763) existed with no hall control, so a
+// wrong routing pick meant a re-file. Metic+ gets a picker on the record now;
+// the server re-enforces rank + the goal-in-same-version rule (ADR 0016) — this
+// only draws what to offer and reads the server's own refusal verbatim.
+
+test('the move-to-goal picker renders for Metic/Archon and not for Xenos/Thetes', async () => {
+  for (const rank of ['metic', 'archon']) {
+    const r = renderTask(BASE_TASK, { viewer: { rank } });
+    await r.boot(); await settle();
+    assert.match(r.html(), /id="move-goal-select"/, `${rank} sees the move-to-goal control`);
+  }
+  for (const rank of ['xenos', 'thetes']) {
+    const r = renderTask(BASE_TASK, { viewer: { rank } });
+    await r.boot(); await settle();
+    assert.doesNotMatch(r.html(), /id="move-goal-select"/, `${rank} must not see the move-to-goal control`);
+  }
+});
+
+test('a successful move-to-goal PATCH re-renders the goal line against the new goal', async () => {
+  const task = { ...BASE_TASK, goal_id: 1000071 };
+  const goalsList = [{ id: 1000071, title: 'Old goal', status: 'open' }, { id: 555, title: 'New goal', status: 'open' }];
+  const r = renderTask(task, { viewer: { rank: 'metic' }, goal: { id: 1000071, title: 'Old goal' }, goalsList });
+  await r.boot(); await settle();
+  assert.match(r.html(), /Goal <a href="\/goals#\/goal\/1000071">1000071/, 'starts on the original goal');
+  r.el('move-goal-select').value = '555';
+  await r.el('move-goal-btn')._handlers.click();
+  await settle();
+  assert.match(r.html(), /Goal <a href="\/goals#\/goal\/555">555/,
+    'the goal line reflects the new goal after the PATCH triggers a reload');
+});
+
+test("a move-to-goal refusal (403) surfaces the server's own sentence, verbatim", async () => {
+  const task = { ...BASE_TASK, goal_id: 1000071 };
+  const goalsList = [{ id: 1000071, title: 'Old goal', status: 'open' }, { id: 555, title: 'New goal', status: 'open' }];
+  const serverMsg = 'Only an Archon may reassign a security-sensitive task.';
+  const r = renderTask(task, {
+    viewer: { rank: 'metic' }, goalsList,
+    patch: { status: 403, data: { error: { code: 'rank_forbidden', message: serverMsg } } },
+  });
+  await r.boot(); await settle();
+  r.el('move-goal-select').value = '555';
+  await r.el('move-goal-btn')._handlers.click();
+  await settle();
+  assert.ok(r.toasts.some((m) => m.includes(serverMsg)),
+    `the server's own sentence must reach the toast, not a generic fallback — got: ${r.toasts.join(' | ')}`);
+  assert.equal(task.goal_id, 1000071, 'a refused PATCH must not move the task locally');
+});

package/tests/idea_routing.mjs

@@ -213,6 +213,39 @@ await test('a named goal the matrix DECLINES is kept as the core_222 hint, not d
     'and the reason says WHY it declined, so a filer is not left guessing');
 });
 
+await test('suggestedGoalId (task 1003068, BV1.R12): writes the hint, never routes, for an ORDINARY kind', async () => {
+  // The case goalId can't cover: an ordinary feature/bug-classified kind with
+  // NO human routing decision (goalId absent) still needs the hint recorded —
+  // this is the Discord #ideas classifier's vector. Passing goalId here would
+  // ROUTE (create a task) for any non-judgment kind; suggestedGoalId must not.
+  reset();
+  const pool = fakePool((s) => (/INSERT INTO idea_inbox/.test(s)
+    ? { rows: [{ ...IDEA_ROW, kind: 'feature', status: 'open', suggested_goal_id: 42 }] } : null));
+  const idea = await captureIdea(
+    { title: 'restock overnight', kind: 'feature', suggestedGoalId: 42, capturedBy: 9 },
+    { pool }
+  );
+  const sqls = seq(pool.queries);
+  assert.equal(sqls.length, 1, 'exactly one statement — no transaction, no route');
+  const ins = find(pool.queries, /INSERT INTO idea_inbox/);
+  assert.match(norm(ins.sql), /'open'/, "status stays 'open'");
+  assert.equal(ins.params[6], 42, 'suggestedGoalId is written as the suggested_goal_id hint');
+  assert.equal(createTaskCalls.length, 0, 'no task is created — a suggestion is not a decision');
+  assert.deepEqual(idea.routing, { routed: false, reason: 'no_goal' },
+    'decideLanding never saw a goalId, so the ordinary no-goal reason applies');
+});
+
+await test('suggestedGoalId is ignored when goalId is ALSO set — a real decision always wins', async () => {
+  reset();
+  const pool = fakePool(routableHandler());
+  await captureIdea(
+    { title: 'broken', kind: 'bug', goalId: 7, suggestedGoalId: 999, capturedBy: 42, filerRank: 'archon' },
+    { pool }
+  );
+  assert.equal(createTaskCalls.length, 1, 'goalId still routes exactly as before');
+  assert.equal(createTaskCalls[0].args.goalId, 7, 'the routed goal is the real decision, not the hint');
+});
+
 await test('the pre-routing validations still fire before any write', async () => {
   reset();
   const pool = fakePool(() => null);

package/tests/planning_session_skill.mjs

@@ -0,0 +1,57 @@
+// tests/planning_session_skill.mjs
+//
+// Static prose assertions on .claude/skills/planning-session/SKILL.md — the
+// skill file IS the deliverable for its own retro tasks (goal 1000071's
+// planning-session retro), so what's checkable is the documented contract,
+// not runtime behavior. Prose is asserted against a whitespace-normalised
+// copy (markdown is hard-wrapped and the checkout reads CRLF back, so a
+// phrase worth asserting will straddle a newline or a \r) — the
+// idea_triage_recommends.mjs precedent.
+//
+// Run: node --test --test-reporter=tap tests/planning_session_skill.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SKILL = fs.readFileSync(path.join(ROOT, '.claude/skills/planning-session/SKILL.md'), 'utf8');
+const NORM = SKILL.replace(/\s+/g, ' ');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- task 1003076: seed scripts verify their own criterion links -----------
+
+test('the seeding contract documents the self-check convention', () => {
+  assert.ok(NORM.includes('verifySeedCriteriaLinks'), 'names the helper function');
+  assert.ok(NORM.includes('seed-verify-criteria.js'), 'names the shared helper file');
+  assert.ok(NORM.includes('GET /api/gds/goals/<id>'), 'names the endpoint the self-check fetches');
+});
+
+test('the self-check is described as failing loudly on any mismatch, zero included', () => {
+  assert.ok(/exit\(1\)`?s? with a loud/.test(NORM), 'documents the loud non-zero exit');
+  assert.ok(NORM.includes('zero included'), 'zero is called out explicitly, not just "a mismatch"');
+});
+
+test('the reference implementation is named', () => {
+  assert.ok(NORM.includes('seed-bongos-v1-idea-routing-tasks.js'), 'names the reference seed script');
+});
+
+test('the retro incident (RETRO2 / learning 1000188) is cited as the reason', () => {
+  assert.ok(NORM.includes('learning 1000188'));
+  assert.ok(NORM.includes('goal 1000071'));
+});
+
+test('step 5 (run the seed script) points at the self-check rather than treating exit 0 as sufficient on its own', () => {
+  const step5 = NORM.slice(NORM.indexOf('Run the seed script.'));
+  assert.ok(step5.slice(0, 400).includes('verifySeedCriteriaLinks'), 'step 5 references the self-check by name');
+});
+
+console.log(`\nplanning_session_skill: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/seed_verify_criteria.mjs

@@ -0,0 +1,149 @@
+// tests/seed_verify_criteria.mjs
+//
+// task 1003076 — the retro on goal 1000071's idea-routing seed: it linked all
+// 15 tasks to the WRONG criteria (positional "Cn" tokens resolving version-
+// wide instead of per-goal, learning 1000188) and still printed success. The
+// mislink was only caught by a manual GET /goals rollup, after the fact.
+//
+// scripts/gds/seed-verify-criteria.js is the fix: every seed script tallies
+// the criterion_ids it actually POSTed, then diffs that plan against
+// GET /api/gds/goals/<id>'s real linked_tasks counts — loud and non-zero-exit
+// on any mismatch, zero included. This file pins the pure diff/tally
+// functions and the exit(1)-on-mismatch behavior with no network dependency.
+//
+// Run: node --test --test-reporter=tap tests/seed_verify_criteria.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const {
+  diffCriterionLinks,
+  expectedCriterionCounts,
+  verifySeedCriteriaLinks,
+} = require('../scripts/gds/seed-verify-criteria.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+async function testAsync(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- expectedCriterionCounts: the plan, tallied from what was POSTed -------
+
+test('tallies one count per criterion_id across all tasks', () => {
+  const counts = expectedCriterionCounts([
+    ['bug-lands-in-its-goal', 'no-route-loses-the-author'],
+    ['bug-lands-in-its-goal'],
+    ['inbox-holds-only-homeless'],
+  ]);
+  assert.deepEqual(counts, {
+    'bug-lands-in-its-goal': 2,
+    'no-route-loses-the-author': 1,
+    'inbox-holds-only-homeless': 1,
+  });
+});
+
+test('a criterion no task cites is simply absent from the plan', () => {
+  const counts = expectedCriterionCounts([['a'], ['a']]);
+  assert.equal(counts.b, undefined);
+});
+
+// --- diffCriterionLinks: expected vs the real GET /goals/:id counts --------
+
+test('matching counts produce no mismatches', () => {
+  const diff = diffCriterionLinks(
+    { a: 2, b: 1 },
+    [{ criterion_id: 'a', linked_tasks: 2 }, { criterion_id: 'b', linked_tasks: 1 }],
+  );
+  assert.deepEqual(diff, []);
+});
+
+test('a criterion linked to zero tasks when N were planned is caught', () => {
+  // The exact shape of the RETRO2 incident: the goal's own criteria row comes
+  // back with linked_tasks: 0 because every task actually landed under a
+  // DIFFERENT (wrong) criterion.
+  const diff = diffCriterionLinks(
+    { 'bug-lands-in-its-goal': 3 },
+    [{ criterion_id: 'bug-lands-in-its-goal', linked_tasks: 0 }],
+  );
+  assert.equal(diff.length, 1);
+  assert.deepEqual(diff[0], { criterion_id: 'bug-lands-in-its-goal', expected: 3, actual: 0 });
+});
+
+test('an over-linked criterion is caught too, not just zero', () => {
+  const diff = diffCriterionLinks(
+    { a: 1 },
+    [{ criterion_id: 'a', linked_tasks: 4 }],
+  );
+  assert.deepEqual(diff, [{ criterion_id: 'a', expected: 1, actual: 4 }]);
+});
+
+test('linked_tasks arrives as a string (pg count) and still compares numerically', () => {
+  const diff = diffCriterionLinks({ a: 2 }, [{ criterion_id: 'a', linked_tasks: '2' }]);
+  assert.deepEqual(diff, []);
+});
+
+test('a criterion missing from the GET /goals response reads as zero, not skipped', () => {
+  const diff = diffCriterionLinks({ a: 1, b: 2 }, [{ criterion_id: 'a', linked_tasks: 1 }]);
+  assert.deepEqual(diff, [{ criterion_id: 'b', expected: 2, actual: 0 }]);
+});
+
+// --- verifySeedCriteriaLinks: the loud exit(1) wrapper ----------------------
+
+await testAsync('zero links where N were planned exits non-zero with a loud message', async () => {
+  const logs = [];
+  let exitCode = null;
+  await verifySeedCriteriaLinks({
+    goalId: 1000071,
+    expectedCounts: { 'bug-lands-in-its-goal': 3 },
+    fetchGoal: async () => ({
+      ok: true, status: 200,
+      json: { criteria: [{ criterion_id: 'bug-lands-in-its-goal', linked_tasks: 0 }] },
+    }),
+    log: (line) => logs.push(line),
+    exit: (code) => { exitCode = code; },
+  });
+  assert.equal(exitCode, 1);
+  assert.ok(logs.some((l) => l.includes('VERIFY FAILED')), 'expected a loud VERIFY FAILED line');
+  assert.ok(logs.some((l) => l.includes('bug-lands-in-its-goal')), 'expected the offending criterion named');
+});
+
+await testAsync('a plan that matches reality does not exit and logs VERIFY OK', async () => {
+  const logs = [];
+  let exitCalled = false;
+  await verifySeedCriteriaLinks({
+    goalId: 1000071,
+    expectedCounts: { a: 2, b: 1 },
+    fetchGoal: async () => ({
+      ok: true, status: 200,
+      json: { criteria: [{ criterion_id: 'a', linked_tasks: 2 }, { criterion_id: 'b', linked_tasks: 1 }] },
+    }),
+    log: (line) => logs.push(line),
+    exit: () => { exitCalled = true; },
+  });
+  assert.equal(exitCalled, false);
+  assert.ok(logs.some((l) => l.includes('VERIFY OK')));
+});
+
+await testAsync('a failed/malformed GET is treated as a verification failure, not silence', async () => {
+  let exitCode = null;
+  const logs = [];
+  await verifySeedCriteriaLinks({
+    goalId: 1000071,
+    expectedCounts: { a: 1 },
+    fetchGoal: async () => ({ ok: false, status: 500, json: null }),
+    log: (line) => logs.push(line),
+    exit: (code) => { exitCode = code; },
+  });
+  assert.equal(exitCode, 1);
+  assert.ok(logs.some((l) => l.includes('VERIFY FAILED')));
+});
+
+console.log(`\nseed_verify_criteria: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);