@bongos/core 1.19.814 → 1.19.816

package/modules/lifecycle/db-goals.js

@@ -832,6 +832,41 @@ async function listCriteriaForGoal(goalId, deps = {}) {
   }));
 }
 
+// listCriterionTextForGoals — every goal's done-when criterion prose, keyed by
+// goal id, in ONE query (task 1003859). The goal suggester ranks on this.
+//
+// WHY BULK. The suggester scores all open goals for a version at once — eleven
+// of them on BONGOS-V2 — so per-goal reads would be eleven round trips on a
+// path that runs at capture time, for prose that is a few hundred bytes a goal.
+//
+// NO INDEX ON goal_id, DELIBERATELY. done_when_criteria carries a handful of rows
+// per goal and low hundreds in total — a scan of it is cheaper than the index it
+// would need maintaining, and adding one would mint a migration (a reserved number
+// and human review) to speed up a read that is already the smallest thing on this
+// path. idx_done_when_version exists for the version-scoped read; revisit if the
+// table ever grows a digit.
+//
+// WHY NOT listCriteriaForGoal. That read carries linked-task counts and the
+// pending_review derivation, none of which a text ranker wants; this returns the
+// criterion prose and nothing else.
+async function listCriterionTextForGoals(goalIds, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const ids = (goalIds || []).map((g) => String(g)).filter(Boolean);
+  if (ids.length === 0) return new Map();
+  const { rows } = await activePool.query(
+    `SELECT goal_id, criterion_md
+       FROM done_when_criteria
+      WHERE goal_id = ANY($1::bigint[])`,
+    [ids]
+  );
+  const byGoal = new Map();
+  for (const r of rows) {
+    const k = String(r.goal_id);
+    byGoal.set(k, (byGoal.get(k) ? byGoal.get(k) + ' ' : '') + String(r.criterion_md || ''));
+  }
+  return byGoal;
+}
+
 // isGoalMember — is this builder a member of this goal? The membership predicate
 // behind the bounded-authority gates (BV1.R64 ask-to-widen; the R60 authoring
 // gate reuses the same idea). Returns a plain boolean.
@@ -1251,6 +1286,7 @@ module.exports = {
   isGoalMember,
   listActiveClaimsForTasks,
   listCriteriaForGoal,
+  listCriterionTextForGoals,
   openTasksInGoal,
   listGoalMembers,
   listGoals,

package/modules/lifecycle/db.js

@@ -88,6 +88,7 @@ const {
   isGoalMember,
   listActiveClaimsForTasks,
   listCriteriaForGoal,
+  listCriterionTextForGoals,
   archiveGoalWithDispositions,
   openTasksInGoal,
   listGoalMembers,
@@ -267,6 +268,7 @@ module.exports = {
   listInboxFor,
   listPendingRequestsForGoal,
   listCriteriaForGoal,
+  listCriterionTextForGoals,
   archiveGoalWithDispositions,
   openTasksInGoal,
   xenosClaimAllowed,

package/modules/lifecycle/goal-suggest.js

@@ -18,12 +18,25 @@
 // so there is one notion of "these two texts are about the same thing" in the
 // module, not two.
 //
-// WHAT A GOAL IS MATCHED ON: its title and its scope_modules. Deliberately NOT
-// its description — a goal description is where a whole planning spec lives (goal
-// 1000062 carries an entire decision record in its), so it shares tokens with
-// almost any draft and would flatten every score toward the same number. Modules
-// are included because they are a strong, cheap signal: a draft about the hall
-// really does belong with a goal scoped to `hall-ui`.
+// WHAT A GOAL IS MATCHED ON: its title, its scope_modules, and its DONE-WHEN
+// CRITERIA (task 1003859). Criteria were added because title-only ranking went
+// dead the moment the goal board adopted ADR 0264's naming: all eleven open
+// BONGOS-V2 goals are titled 'Working area N — <subject>', so a real subject word
+// in a draft — 'release', 'grader', 'dependency' — had almost nothing to overlap,
+// every goal scored under threshold, and the suggester returned [] for every idea
+// walked at the 2026-09-12 triage. It also left suggested_goal_id NULL at capture
+// time on every BONGOS-V2 filing, so triage inherited nothing either. The criteria
+// carry the subject vocabulary the titles stopped carrying.
+//
+// Criterion terms are weighted BELOW title terms (see CRITERION_WEIGHT): a goal
+// named for the subject is still the stronger claim, and criteria are longer text
+// that would otherwise swamp it.
+//
+// Still deliberately NOT the goal DESCRIPTION — a goal description is where a whole
+// planning spec lives (goal 1000062 carries an entire decision record in its), so
+// it shares tokens with almost any draft and would flatten every score toward the
+// same number. Modules are included because they are a strong, cheap signal: a
+// draft about the hall really does belong with a goal scoped to `hall-ui`.
 
 const { tokenize } = require('./criterion-suggest.js');
 const { versionAcceptsNewWork } = require('./db-tasks.js');
@@ -38,10 +51,47 @@ const captureErr = (err) => api.logger('lifecycle').error({ err: err && err.mess
 // Matches suggestCriteria's default so the two suggesters feel the same.
 const SUGGEST_LIMIT = 5;
 
+// A criterion term counts for less than the same term in the title. Criteria are
+// several sentences per goal against a title's handful of words, so equal weight
+// would let a goal that merely MENTIONS a subject outrank one NAMED for it.
+const CRITERION_WEIGHT = 0.5;
+
+// rankableCriteria — the criterion prose the ranker may read, for the goals it is
+// about to score. Both callers go through this, so the two rules below have ONE
+// home and cannot drift apart.
+//
+// RULE 1 — PRIVATE GOALS ARE EXCLUDED. This function's own header explains that
+// GET /goals (and therefore this suggester) already lists private goals' TITLES to
+// any signed-in builder, and that reconciling that is a decision about the goal
+// board as a whole rather than something a suggester settles. Criteria are a
+// different order of exposure: score + matched_terms make a ranker into a
+// word-guessing oracle, so ranking on a private goal's done-when prose would let
+// any builder probe the CONTENT of work they cannot see, one candidate word per
+// request. So this addition stops at the visibility line the status quo already
+// draws — a private goal keeps ranking exactly as it did before (title + modules),
+// and nothing new is disclosed. Widening or narrowing the title-level status quo
+// stays the separate decision it was.
+//
+// RULE 2 — BEST EFFORT. A criteria read that fails degrades to title-only ranking,
+// which is what this path did before the criteria existed. A suggester is advisory
+// everywhere it is called; taking down a bug report or 500ing a picker to protect
+// a ranking refinement would be the wrong trade.
+async function rankableCriteria(db, goals, onError) {
+  if (typeof db.listCriterionTextForGoals !== 'function') return null;
+  const rankable = (goals || []).filter((g) => g && g.visibility !== 'private');
+  if (rankable.length === 0) return null;
+  try {
+    return await db.listCriterionTextForGoals(rankable.map((g) => g.id));
+  } catch (err) { onError(err); return null; }
+}
+
 // Rank open goals against a DRAFT capture. Pure — no DB, no writes; the caller
 // supplies the goal rows.
 //
 //   goals   — open goal rows { id, title, scope_modules }
+//   opts.criteriaByGoal — Map<goalId, criterion prose> (db.listCriterionTextForGoals).
+//             Optional: omitted, this ranks exactly as it did before — the pure
+//             function stays callable with no DB anywhere near it.
 //   draft   — { title, body } (body optional: a capture's prose, weighted lower)
 //   opts    — { versionId, limit, includeZero }
 //
@@ -54,7 +104,7 @@ const SUGGEST_LIMIT = 5;
 // offer "browse all" without this function pretending to a confidence it lacks.
 function suggestGoals(goals, draft = {}, opts = {}) {
   const { title = '', body = '' } = draft;
-  const { versionId = null, limit = SUGGEST_LIMIT, includeZero = false } = opts;
+  const { versionId = null, limit = SUGGEST_LIMIT, includeZero = false, criteriaByGoal = null } = opts;
 
   // Weighted term map: body terms at 1, title terms override to 2 (a term in
   // both IS a title term — the stronger signal wins). suggestCriteria's rule.
@@ -73,10 +123,20 @@ function suggestGoals(goals, draft = {}, opts = {}) {
       // by the >=3-char filter, which is fine — 'hall' is the signal.
       ...tokenize((g.scope_modules || []).join(' ')),
     ]);
+    // Criterion terms that the title/modules already cover add nothing — they are
+    // scored at the full title weight above, and double-counting would reward a
+    // goal for repeating itself.
+    const criterionTerms = new Set();
+    if (criteriaByGoal) {
+      for (const t of tokenize(criteriaByGoal.get(String(g.id)) || '')) {
+        if (!goalTerms.has(t)) criterionTerms.add(t);
+      }
+    }
     let score = 0;
     const matched = [];
     for (const [term, w] of weights) {
       if (goalTerms.has(term)) { score += w; matched.push(term); }
+      else if (criterionTerms.has(term)) { score += w * CRITERION_WEIGHT; matched.push(term); }
     }
     return { ...g, score, matched_terms: matched.sort() };
   }).sort((a, b) => (b.score - a.score) || (Number(a.id) - Number(b.id)));
@@ -133,11 +193,16 @@ async function suggestGoalForCapture({ title = '', body = '' } = {}, deps = {})
       && g.title !== generalGoalTitle(g.version_id));
     if (homes.length === 0) return null;
 
+    // Criterion prose for the same goals — this is the capture-time half of task
+    // 1003859, and it is the half that matters most: suggested_goal_id is written
+    // HERE, and it was NULL on every BONGOS-V2 filing.
+    const criteriaByGoal = await rankableCriteria(db, homes, captureErr);
+
     // versionId is passed null: the catch-alls are already gone, and passing one
     // version's id here would only re-filter for that version. includeZero stays
     // false, so a filing that matches nothing gets NO goal rather than the
     // first one dressed up as a suggestion.
-    const [best] = suggestGoals(homes, { title, body }, { versionId: null, limit: 1 });
+    const [best] = suggestGoals(homes, { title, body }, { versionId: null, limit: 1, criteriaByGoal });
     if (!best) return null;
 
     // suggestGoals normalises to { id, title, scope_modules, … } and drops
@@ -184,7 +249,8 @@ function goalSuggestHandler({ db, LIMITS }) {
     // was an oversight, not a decision.
     try {
       const open = await db.listGoals({ versionId, status: 'open' });
-      const suggestions = suggestGoals(open, { title, body }, { versionId, limit });
+      const criteriaByGoal = await rankableCriteria(db, open || [], proseErr);
+      const suggestions = suggestGoals(open, { title, body }, { versionId, limit, criteriaByGoal });
       return res.json({
         version_id: versionId,
         // `kind` is echoed, NOT ranked on. Kind decides how a capture LANDS (the

package/modules/lifecycle/routes/lifecycle.js

@@ -44,12 +44,30 @@ const cascade = require('../cascade');
 // leave it. Nothing here can affect the ship: the emitters fire post-commit and
 // already wrap the emit, and `runCascadesForShip` resolves rather than throws.
 let _cascadeListenerOff = null;
+let _ideaCascadeListenerOff = null;
 
 function registerSeams() {
   if (!api.hasProvider('lifecycle')) {
     api.registerProvider('lifecycle', lifecycle);
   }
   if (_cascadeListenerOff) _cascadeListenerOff();
+  // Torn down with its sibling: the factory runs again every time a test rebuilds
+  // the router, and a leaked subscription would fire this cascade twice.
+  if (_ideaCascadeListenerOff) _ideaCascadeListenerOff();
+  // task 1003856: the second cross-role cascade. Same module, same runner
+  // guarantees, different trigger — an idea reaching Full rather than a ship.
+  _ideaCascadeListenerOff = api.on('idea.graded.full', (graded) => cascade.runCascadesForIdea(graded, {
+    // No getIdea: the ideas module owns that row and sends it whole. Injecting a
+    // reader here would mean lifecycle querying another module's table.
+    findTaskBySourceRef: (q) => db.findTaskBySourceRef(q),
+    createTask: (spec) => db.createTask(spec),
+    // INVOKED, like its sibling below. api.logger is a FACTORY (api.logger(ns)),
+    // so passing it bare left every log?.info?.() call resolving to undefined and
+    // silently doing nothing — the optional chaining that makes the runner safe is
+    // also what hid this.
+    log: api.logger ? api.logger('lifecycle') : null,
+  }));
+
   _cascadeListenerOff = api.on('task.shipped', (shipped) => cascade.runCascadesForShip(shipped, {
     getTask: (id) => db.getTask(id),
     findTaskBySourceRef: (ref) => db.findTaskBySourceRef(ref),

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.814",
+  "version": "1.19.816",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.814",
+      "version": "1.19.816",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.814",
+  "version": "1.19.816",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/scripts/gds/capture.js

@@ -50,8 +50,12 @@
 //                                 the active-claim default below is skipped —
 //                                 an opt-out that still guessed a goal would not
 //                                 be an opt-out.
-//                  (neither)    → default to the ACTIVE CLAIM's goal, if this
-//                                 builder holds one and its task has a goal
+//                  (neither)    → default to the ACTIVE CLAIM's goal — but ONLY
+//                                 when the captured text and the claimed task
+//                                 share a subject word (task 1003859); an
+//                                 unrelated filing says so and stays homeless.
+//                                 Applies if this builder holds a claim and its
+//                                 task has a goal
 //                                 ("capturing mid-work almost always concerns
 //                                 the work" — the interview's own words). With
 //                                 no default to offer, the R07 suggester
@@ -160,6 +164,29 @@ function sanitizeForTerminal(s) {
   return String(s == null ? '' : s).replace(/[\x00-\x1f\x7f]/g, '');
 }
 
+// claimShareSubject — does the captured text have ANYTHING in common with the
+// task I happen to be holding? (task 1003859)
+//
+// WHY THE DEFAULT NEEDED A GUARD. The active-claim default is a convenience for
+// the ordinary case: you are working on X and you file something about X. But it
+// fired unconditionally, so filing an UNRELATED bug mid-session minted it into
+// the claim's goal — this very bug was filed from a session holding a security
+// task and landed in Working area 10 (Security), which has nothing to do with it,
+// and had to be moved by hand. ADR 0234's owner-interview decision is that a
+// guess must not mint work into a goal, and an inherited goal with no subject in
+// common is exactly a guess.
+//
+// Reuses criterion-suggest's tokenize — the same notion of 'these two texts are
+// about the same thing' the goal suggester ranks with, so the guard and the
+// suggester cannot disagree about what a subject word is.
+const { tokenize } = require('../../modules/lifecycle/criterion-suggest.js');
+
+function claimShareSubject(capturedText, claimTitle) {
+  const theirs = new Set(tokenize(claimTitle));
+  if (theirs.size === 0) return true; // nothing to disagree with — keep the old behaviour
+  return tokenize(capturedText).some((t) => theirs.has(t));
+}
+
 // resolveGoalForCapture — the WHOLE of --goal resolution for one capture, in the
 // interview's own precedence: an explicit id wins outright; 'none' is a hard
 // opt-out (no default, no hint); otherwise the active-claim default runs, and
@@ -168,26 +195,34 @@ function sanitizeForTerminal(s) {
 // is testable without capturing stdout. Never throws (both collaborators above
 // already degrade to null on their own).
 async function resolveGoalForCapture({ goalArg, version, title, kind, client = cliClient } = {}) {
+  const claimLines = [];
   const parsed = parseGoalArg(goalArg);
   if (parsed.kind === 'id') return { goalId: parsed.id, lines: [] };
   if (parsed.kind === 'none') return { goalId: null, lines: [] };
 
   const defaulted = await resolveActiveClaimGoal({ client });
   if (defaulted) {
-    return {
-      goalId: defaulted.goalId,
-      lines: [`↪ defaulting --goal to ${defaulted.goalId} from your active claim on task #${defaulted.taskId} ("${sanitizeForTerminal(defaulted.taskTitle)}") — override with --goal <id>, or --goal none to file homeless.`],
-    };
+    // Only inherit when the two are actually about the same thing. When they are
+    // not, say so and fall through to the suggester — which ranks on what was
+    // WRITTEN rather than on what happens to be open — instead of filing silently
+    // into the wrong goal.
+    if (claimShareSubject(title, defaulted.taskTitle)) {
+      return {
+        goalId: defaulted.goalId,
+        lines: [`↪ defaulting --goal to ${defaulted.goalId} from your active claim on task #${defaulted.taskId} ("${sanitizeForTerminal(defaulted.taskTitle)}") — override with --goal <id>, or --goal none to file homeless.`],
+      };
+    }
+    claimLines.push(`↪ NOT defaulting to your active claim's goal: task #${defaulted.taskId} ("${sanitizeForTerminal(defaulted.taskTitle)}") shares no subject with what you filed — pass --goal ${defaulted.goalId} if it really belongs there.`);
   }
 
   const hint = await fetchGoalSuggestion({ client, version, title, kind });
   if (hint) {
     return {
       goalId: null,
-      lines: [`💡 possible home: goal ${hint.id} "${sanitizeForTerminal(hint.title)}" (score ${hint.score}) — re-run with --goal ${hint.id} (or --goal none to stay homeless on purpose).`],
+      lines: [...claimLines, `💡 possible home: goal ${hint.id} "${sanitizeForTerminal(hint.title)}" (score ${hint.score}) — re-run with --goal ${hint.id} (or --goal none to stay homeless on purpose).`],
     };
   }
-  return { goalId: null, lines: [] };
+  return { goalId: null, lines: claimLines };
 }
 
 // DEFAULT IS NO, and only an explicit yes counts. Extracted so the done-when

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.814'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.816'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/agents_validate.mjs

@@ -11,6 +11,9 @@
 //
 // Run:  node tests/agents_validate.mjs
 
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
@@ -73,9 +76,37 @@ await test('a failed validation returns NO value — nothing downstream can inse
 
 // --- THE EVENT CATALOG — the fail-closed rule -------------------------------
 
-await test('EVENT_CATALOG is exactly the v1 wired set, and is frozen', () => {
-  assert.deepEqual(EVENT_CATALOG, ['task.shipped']);
+await test('EVENT_CATALOG is frozen, and every entry is REALLY dispatched', () => {
   assert.equal(Object.isFrozen(EVENT_CATALOG), true, 'a caller must not be able to widen the catalog at runtime');
+  assert.ok(EVENT_CATALOG.includes('task.shipped'), 'the original wired event stays wired');
+
+  // The catalog's own comment is the rule: widening it "must land together with
+  // something that actually dispatches the new event". Pinned as that rule rather
+  // than as a frozen list, because a list cannot tell a legitimate widening from
+  // one that ships an entry nothing emits — and the second produces an agent that
+  // looks armed and never fires, which is the failure the catalog exists to stop.
+  const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const files = [];
+  const walk = (dir) => {
+    let ents = [];
+    try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { if (e.name !== 'node_modules') walk(full); continue; }
+      if (e.name.endsWith('.js')) files.push(full);
+    }
+  };
+  for (const d of ['src', 'modules']) walk(path.join(ROOT, d));
+  const tree = files.map((f) => fs.readFileSync(f, 'utf8')).join('\n');
+
+  for (const event of EVENT_CATALOG) {
+    // Any quote style, emit or emitAsync. A plain substring scan rather than a
+    // built regex: the thing being asserted is "somebody emits this string".
+    const dispatched = ['emit(', 'emitAsync('].some((call) =>
+      [String.fromCharCode(39), '"', String.fromCharCode(96)].some((q) => tree.includes(call + q + event + q)));
+    assert.ok(dispatched,
+      `"${event}" is in the catalog but nothing in src/ or modules/ emits it — an agent armed on it would never fire`);
+  }
 });
 
 await test('an UNWIRED event name is REFUSED, never silently accepted', () => {

package/tests/capture_goal_routing.mjs

@@ -181,7 +181,11 @@ await test('no --goal: the active-claim default fires and names how to opt out',
     me: { ok: true, data: { active_claims: [{ task_id: 55, title: 'Fix the thing' }] } },
     task: { ok: true, data: { task: { id: 55, goal_id: 1000071, title: 'Fix the thing' } } },
   });
-  const r = await capture.resolveGoalForCapture({ goalArg: null, version: 'BV1', title: 't', client });
+  // The captured text shares 'thing' with the claim — the ordinary case the
+  // default exists for. (It used to be the bare title 't'; since task 1003859 the
+  // default only fires on a shared subject word, so a placeholder no longer
+  // exercises this path.)
+  const r = await capture.resolveGoalForCapture({ goalArg: null, version: 'BV1', title: 'the thing is broken', client });
   assert.equal(r.goalId, 1000071);
   assert.equal(r.lines.length, 1);
   assert.match(r.lines[0], /1000071/);
@@ -239,4 +243,64 @@ await test('WIRING: a routing refusal is surfaced through the existing verbatim
   assert.match(CAPTURE_SRC, /console\.error\(formatCaptureFailure\(r\.status, r\.data\)\);/);
 });
 
+// ---------------------------------------------------------------------------
+// the active-claim default must not mint UNRELATED work into the claim's goal
+// (task 1003859)
+// ---------------------------------------------------------------------------
+//
+// The default fired unconditionally, so filing an unrelated bug mid-session
+// routed it into whatever goal you happened to be holding — task 1003859 itself
+// was filed from a security claim and landed in Working area 10, and had to be
+// moved by hand. ADR 0234: a guess must not mint work into a goal.
+
+await test('no --goal, claim shares NO subject with the filing: does not inherit, and says why', async () => {
+  const { client, calls } = stubClient({
+    me: { ok: true, data: { active_claims: [{ task_id: 55, title: 'Harden the OAuth callback against replay' }] } },
+    task: { ok: true, data: { task: { id: 55, goal_id: 1000094, title: 'Harden the OAuth callback against replay' } } },
+    suggestions: { ok: true, data: { suggestions: [] } },
+  });
+  const r = await capture.resolveGoalForCapture({
+    goalArg: null, version: 'BV1', title: 'The goal suggester returns zero suggestions for every idea', client,
+  });
+  assert.equal(r.goalId, null, 'an unrelated claim must not decide where this work lives');
+  assert.equal(r.lines.length, 1, 'staying homeless silently would be the same bug with no evidence');
+  assert.match(r.lines[0], /NOT defaulting/);
+  assert.match(r.lines[0], /1000094/, 'it must name the goal it declined, so --goal can override it');
+  assert.equal(calls.suggestions.length, 1, 'with no default, the suggester still gets its turn');
+});
+
+await test('a declined default still yields to a real suggestion, keeping both lines', async () => {
+  const { client } = stubClient({
+    me: { ok: true, data: { active_claims: [{ task_id: 55, title: 'Harden the OAuth callback against replay' }] } },
+    task: { ok: true, data: { task: { id: 55, goal_id: 1000094, title: 'Harden the OAuth callback against replay' } } },
+    suggestions: { ok: true, data: { suggestions: [{ id: 1000091, title: 'Working area 7', score: 3 }] } },
+  });
+  const r = await capture.resolveGoalForCapture({
+    goalArg: null, version: 'BV1', title: 'The goal suggester returns zero suggestions', client,
+  });
+  assert.equal(r.goalId, null);
+  assert.equal(r.lines.length, 2, 'the refusal and the hint are different facts — both are printed');
+  assert.match(r.lines[0], /NOT defaulting/);
+  assert.match(r.lines[1], /1000091/);
+});
+
+await test('--goal N still wins outright over the guard (it is not a veto)', async () => {
+  const { client, calls } = stubClient({
+    me: { ok: true, data: { active_claims: [{ task_id: 55, title: 'Something else entirely' }] } },
+    task: { ok: true, data: { task: { id: 55, goal_id: 1000094 } } },
+  });
+  const r = await capture.resolveGoalForCapture({ goalArg: '1000094', version: 'BV1', title: 'unrelated words here', client });
+  assert.deepEqual(r, { goalId: 1000094, lines: [] });
+  assert.equal(calls.me, 0);
+});
+
+await test('a claim title with no subject words at all still inherits — the guard only fires on real disagreement', async () => {
+  const { client } = stubClient({
+    me: { ok: true, data: { active_claims: [{ task_id: 55, title: 'a' }] } },
+    task: { ok: true, data: { task: { id: 55, goal_id: 1000071, title: 'a' } } },
+  });
+  const r = await capture.resolveGoalForCapture({ goalArg: null, version: 'BV1', title: 'anything at all', client });
+  assert.equal(r.goalId, 1000071, 'nothing to compare against is not evidence of a mismatch');
+});
+
 summary();