@bongos/core 1.19.288 → 1.19.290

package/src/bongos/route-rank-check.js

@@ -362,6 +362,9 @@ const MODULE_EXPECTED_RANKS = {
     // Pinning catches an accidental requireRank re-gate that would lock builders
     // out of asking/accepting, and any gate removal.
     'GET /goals/inbox': 'any-builder',
+    // task 1003062 (R07): a pre-creation READ of open goal titles — same surface
+    // and same rank as GET /goals. Creates nothing.
+    'GET /goals/suggestions': 'any-builder',
     'PATCH /goals/:id/visibility': 'any-builder',
     // task 1003102: a goal's own authority (owner|manager|Archon, in-handler
     // authorizeGoalManagement) corrects its own title/description — same shape
@@ -506,8 +509,20 @@ function classifyGate(lines, i, { floors } = {}) {
   // (not any `=>`) avoids cutting at an inline-arrow middleware like
   // `rateLimit({ key: (req) => req.ip })`. If there's no `=> {` in the window
   // (e.g. a `function` handler), fall back to the full window — prior behaviour.
-  const handlerAt = window.search(/=>\s*\{/);
-  const tail = handlerAt === -1 ? window : window.slice(0, handlerAt);
+  // task 1003062: FIRST clamp the window to THIS route's own declaration. The
+  // `=> {` truncation below only fires for an inline-arrow handler; a route whose
+  // handler is a FACTORY CALL — `router.get(p, auth.requireBuilder, mk({...}))` —
+  // contains no `=> {`, so the old code fell back to the full 20 lines and
+  // absorbed the NEXT route's requirePermission, recording an any-builder read as
+  // metic+archon. Wrong in the tightening direction, but still wrong: the pin and
+  // the audit then describe a gate that is not there. Factory handlers became
+  // common because the fitness oversize ratchet pushes handler bodies out of large
+  // route files, so this is not an exotic shape. A window must never cross into a
+  // sibling declaration.
+  const nextRouteAt = window.search(/\n\s*router\.(get|post|patch|put|delete|use)\s*\(/);
+  const own = nextRouteAt === -1 ? window : window.slice(0, nextRouteAt);
+  const handlerAt = own.search(/=>\s*\{/);
+  const tail = handlerAt === -1 ? own : own.slice(0, handlerAt);
 
   const perms = permissionKeysIn(tail);
   const byRank = rankFromRankGate(tail);

package/src/module-api.js

@@ -1003,8 +1003,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.286 with no explicit bump. run 32539649191. (task 1002620)
 //   1.19.288 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.287 with no explicit bump. run 32546561232. (task 1002620)
+//   1.19.289 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.288 with no explicit bump. run 32549912116. (task 1002620)
+//   1.19.290 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.289 with no explicit bump. run 32552538814. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.288'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.290'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/goal_suggest.mjs

@@ -0,0 +1,195 @@
+// tests/goal_suggest.mjs — the pre-creation goal suggester (task 1003062 / R07 of
+// goal 1000071).
+//
+// "Which goal should this work live in?", answered BEFORE anything is created.
+// buildGoalAdvisory already answered it, but only AFTER a task existed; R08 (hall
+// picker), R09 (CLI) and R11 (Discord) all have a draft title and no row yet.
+//
+// What these pin:
+//  1. It CREATES NOTHING. That is the entire point of a pre-creation read, and the
+//     easiest thing for a later refactor to break by routing it through a writer.
+//  2. RANKING, not "the first five open goals" — with the honest limits of token
+//     overlap written down rather than papered over (see the false-positive test).
+//  3. The catch-all is never suggested (it is the fallback when there is no home —
+//     a different question, owned by R03).
+//  4. No confident match returns [] rather than noise, and the route still tells
+//     the caller how many goals exist so it can offer "browse all" honestly.
+//
+// Run:  node tests/goal_suggest.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const { suggestGoals, goalSuggestHandler, SUGGEST_LIMIT } = require('../modules/lifecycle/goal-suggest.js');
+const { test, summary } = makeRunner();
+
+const V = 'BONGOS-V1';
+const GOALS = [
+  { id: 1000024, title: 'Build-pipeline integrity', scope_modules: ['lifecycle', 'grading'] },
+  { id: 1000025, title: 'Builder experience — hall, dev box, and skills', scope_modules: ['hall-ui', 'dev-box'] },
+  { id: 1000071, title: 'Idea routing — work that has a home lands in it', scope_modules: ['ideas', 'discord'] },
+  { id: 1000003, title: `${V} — general`, scope_modules: [] },
+];
+
+// ---- 2. it ranks, and the ranking is explainable --------------------------
+
+await test('RANKS: a draft about the ship pipeline puts Build-pipeline integrity first', () => {
+  const r = suggestGoals(GOALS, { title: 'ship pipeline grading is flaky' }, { versionId: V });
+  assert.equal(r[0].id, 1000024);
+  assert.ok(r[0].score >= 4, `two title terms should score >=4, got ${r[0].score}`);
+  assert.deepEqual(r[0].matched_terms, ['grading', 'pipeline'], 'and it SAYS why it matched');
+});
+
+await test('RANKS: a module key is a matchable signal, not just the title', () => {
+  // 'discord' appears only in scope_modules for goal 1000071.
+  const r = suggestGoals(GOALS, { title: 'discord filing loses the author' }, { versionId: V });
+  assert.equal(r[0].id, 1000071);
+  assert.ok(r[0].matched_terms.includes('discord'));
+});
+
+await test('RANKS: title terms outweigh body terms (2 vs 1), same rule as suggestCriteria', () => {
+  const inTitle = suggestGoals(GOALS, { title: 'grading' }, { versionId: V })[0];
+  const inBody = suggestGoals(GOALS, { title: 'unrelated', body: 'grading' }, { versionId: V })[0];
+  assert.equal(inTitle.score, 2);
+  assert.equal(inBody.score, 1);
+});
+
+await test('RANKS: a term in BOTH title and body counts once, at the title weight', () => {
+  const r = suggestGoals(GOALS, { title: 'grading', body: 'grading grading' }, { versionId: V })[0];
+  assert.equal(r.score, 2, 'the stronger signal wins; it does not accumulate');
+});
+
+await test('RANKS: ties break by ascending id so a picker renders stably', () => {
+  const goals = [
+    { id: 900, title: 'routing', scope_modules: [] },
+    { id: 100, title: 'routing', scope_modules: [] },
+    { id: 500, title: 'routing', scope_modules: [] },
+  ];
+  assert.deepEqual(suggestGoals(goals, { title: 'routing' }, { versionId: V }).map((g) => g.id), [100, 500, 900]);
+});
+
+// ---- the honest limit, written down --------------------------------------
+
+await test('LIMIT (known + accepted): token overlap can match on an incidental word', () => {
+  // Real example found while building this: "the goals page search BOX is broken"
+  // scores the DEV BOX goal, because both contain the token 'box'. Bag-of-words
+  // matching cannot tell "search box" from "dev box".
+  //
+  // This is NOT hidden — it is why every suggestion carries `score` and
+  // `matched_terms`: a caller can show WHY it matched and a human decides. A
+  // suggester that silently guessed, with no visible reason, would be worse.
+  // Fixing it properly means real relevance scoring (embeddings/FTS), which is a
+  // separate decision, not something to smuggle into R07.
+  const r = suggestGoals(GOALS, { title: 'the goals page search box is broken' }, { versionId: V });
+  assert.equal(r[0].id, 1000025, 'the incidental match is what happens today');
+  assert.deepEqual(r[0].matched_terms, ['box'], 'and the single weak term is VISIBLE to the caller');
+  assert.equal(r[0].score, 2, 'one title term — a low score, which is the signal it is weak');
+});
+
+// ---- 3. the catch-all is never a suggestion ------------------------------
+
+await test('CATCH-ALL: the "<version> — general" goal is never suggested, even on an exact hit', () => {
+  const r = suggestGoals(GOALS, { title: `${V} general` }, { versionId: V });
+  assert.ok(!r.some((g) => g.id === 1000003), 'the catch-all is the no-home FALLBACK (R03), not a suggestion');
+});
+
+await test('CATCH-ALL: without a versionId it cannot be identified, so nothing is dropped', () => {
+  // candidateGoals keys the catch-all off the version name; no version => no filter.
+  const r = suggestGoals(GOALS, { title: 'general' }, {});
+  assert.ok(r.some((g) => g.id === 1000003), 'documented consequence of omitting versionId');
+});
+
+// ---- 4. no confident match, and bounds ----------------------------------
+
+await test('NO MATCH: a draft matching nothing returns [] rather than arbitrary goals', () => {
+  assert.deepEqual(suggestGoals(GOALS, { title: 'xyzzy plugh frobnicate' }, { versionId: V }), []);
+});
+
+await test('NO MATCH: includeZero:true is available for a caller that wants the full list', () => {
+  const r = suggestGoals(GOALS, { title: 'xyzzy' }, { versionId: V, includeZero: true });
+  assert.equal(r.length, 3, 'all three non-catch-all goals, all scoring 0');
+  assert.ok(r.every((g) => g.score === 0));
+});
+
+await test('BOUNDS: limit defaults to SUGGEST_LIMIT and is respected; degenerate input is safe', () => {
+  assert.equal(SUGGEST_LIMIT, 5);
+  assert.equal(suggestGoals(GOALS, { title: 'routing' }, { versionId: V, limit: 1 }).length, 1);
+  assert.deepEqual(suggestGoals(GOALS, { title: 'routing' }, { versionId: V, limit: 0 }), []);
+  assert.deepEqual(suggestGoals(null, { title: 'x' }, {}), []);
+  assert.deepEqual(suggestGoals(GOALS, {}, { versionId: V }), [], 'no draft text => no suggestions');
+});
+
+// ---- 1. IT CREATES NOTHING ----------------------------------------------
+
+function fakeRes() {
+  return {
+    code: null, payload: null, statusCode: 200,
+    json(p) { this.payload = p; return this; },
+    status(c) { this.statusCode = c; return this; },
+    fail(code, s, extra) { this.code = code; this.statusCode = typeof s === 'number' ? s : (s && s.status) || 500; this.payload = extra || s; return this; },
+  };
+}
+
+await test('CREATES NOTHING: the handler only READS goals — no writer is reachable from it', async () => {
+  const calls = [];
+  const db = { listGoals: async (a) => { calls.push(['listGoals', a]); return GOALS; } };
+  const handler = goalSuggestHandler({ db, LIMITS: { TITLE: 200 } });
+  const res = fakeRes();
+  await handler({ query: { version: V, title: 'ship pipeline grading' } }, res);
+  assert.equal(res.code, null, `expected success, got ${res.code}`);
+  assert.equal(res.payload.suggestions[0].id, 1000024);
+  assert.deepEqual(calls.map((c) => c[0]), ['listGoals'], 'exactly one read, and it is a read');
+  assert.equal(res.payload.created, null, 'the response says so explicitly');
+  // Source contract: nothing in this module may call a create/insert/update path.
+  const src = readFileSync(new URL('../modules/lifecycle/goal-suggest.js', import.meta.url), 'utf8');
+  assert.ok(!/\b(createTask|createGoal|insert|INSERT|UPDATE|captureIdea)\b/.test(src),
+    'a pre-creation suggester must contain no write path at all');
+});
+
+await test('the handler refuses without a version, and without any draft text', async () => {
+  const handler = goalSuggestHandler({ db: { listGoals: async () => GOALS }, LIMITS: { TITLE: 200 } });
+  let res = fakeRes();
+  await handler({ query: { title: 'x' } }, res);
+  assert.equal(res.code, 'version_required');
+  res = fakeRes();
+  await handler({ query: { version: V } }, res);
+  assert.equal(res.code, 'draft_text_required', 'ranking against nothing is not a suggestion');
+});
+
+await test('the handler reports open_goal_count so an empty result is not mistaken for an empty version', async () => {
+  const handler = goalSuggestHandler({ db: { listGoals: async () => GOALS }, LIMITS: { TITLE: 200 } });
+  const res = fakeRes();
+  await handler({ query: { version: V, title: 'xyzzy plugh' } }, res);
+  assert.deepEqual(res.payload.suggestions, []);
+  assert.equal(res.payload.open_goal_count, 4, 'four goals exist; none matched — different facts');
+});
+
+await test('kind is ECHOED but never ranked on (it decides landing, not which goal)', async () => {
+  const handler = goalSuggestHandler({ db: { listGoals: async () => GOALS }, LIMITS: { TITLE: 200 } });
+  const withKind = fakeRes();
+  await handler({ query: { version: V, title: 'grading', kind: 'bug' } }, withKind);
+  const noKind = fakeRes();
+  await handler({ query: { version: V, title: 'grading' } }, noKind);
+  assert.equal(withKind.payload.kind, 'bug', 'echoed');
+  assert.equal(noKind.payload.kind, null);
+  assert.deepEqual(
+    withKind.payload.suggestions.map((s) => [s.id, s.score]),
+    noKind.payload.suggestions.map((s) => [s.id, s.score]),
+    'kind must not change the ranking — the R05 landing matrix owns kind',
+  );
+});
+
+await test('the handler clamps limit into a sane range', async () => {
+  const handler = goalSuggestHandler({ db: { listGoals: async () => GOALS }, LIMITS: { TITLE: 200 } });
+  for (const [q, expectMax] of [[{ limit: '999' }, 20], [{ limit: '0' }, 1], [{ limit: 'abc' }, SUGGEST_LIMIT]]) {
+    const res = fakeRes();
+    await handler({ query: { version: V, title: 'routing grading hall', ...q } }, res);
+    assert.ok(res.payload.suggestions.length <= expectMax, `limit ${JSON.stringify(q)} must clamp`);
+  }
+});
+
+summary();

package/tests/promote_goal_id.mjs

@@ -0,0 +1,316 @@
+// tests/promote_goal_id.mjs — a triaged promotion lands IN A GOAL (task 1003071 / R13).
+//
+// Before this, both promote paths — the hall triage overlay and the /idea-triage
+// CLI — created a task with no goal_id at all. That does NOT mean the task came
+// out goal-less: db.createTask (modules/lifecycle/db.js) defaults a goal-less
+// create into the version's catch-all "<version> — general" goal. That bucket IS
+// the defect. It carries no done-when criteria, so since ADR 0183 made criteria
+// close themselves off LINKED tasks, work parked there can never advance
+// anything — and it does not read as real goal work on the board. Falling into it
+// had to stop being the silent default.
+//
+// What these pin:
+//  1. PRECEDENCE. The stored `suggested_goal_id` hint beats the R07 suggester.
+//     inbox.captureIdea writes that hint even when the matrix declined to route,
+//     specifically so triage "inherits the guess instead of re-deriving it"
+//     (core_222's own comment). A heuristic must never overrule a named goal.
+//  2. OPT-OUT IS EXPLICIT. Taking the general bucket is still allowed — it just
+//     has to be chosen, not defaulted into.
+//  3. DEGRADES, NEVER BLOCKS. A suggester outage must not stop a triage verdict.
+//  4. BOTH PATHS send goal_id. Two surfaces, one contract — the same class of
+//     miss as the two claim-insert sites (task 1003137).
+//
+// Run:  node tests/promote_goal_id.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const { test, summary } = makeRunner();
+
+// triage.js captures `cliClient` by destructuring at require time, so a stub has
+// to be in place BEFORE the module loads. Dropping both from the require cache
+// and re-requiring is what makes that possible per-test.
+function freshTriage() {
+  delete require.cache[require.resolve('../scripts/gds/triage.js')];
+  return require('../scripts/gds/triage.js');
+}
+
+const TRIAGE = readFileSync(new URL('../scripts/gds/triage.js', import.meta.url), 'utf8');
+const HALL = readFileSync(new URL('../modules/hall-ui/public/task-detail.js', import.meta.url), 'utf8');
+const SKILL = readFileSync(new URL('../.claude/skills/idea-triage/SKILL.md', import.meta.url), 'utf8');
+
+// ==========================================================================
+// BEHAVIOURAL — these INVOKE the code. The static assertions further down pin
+// the wiring a unit test cannot reach (the DOM strings, the skill doc); they do
+// not stand in for actually running it.
+// ==========================================================================
+
+const triage = require('../scripts/gds/triage.js');
+
+// A stub of the generated typed client: records the call, answers from a script.
+function stubClient(answer) {
+  const calls = [];
+  const client = async () => ({
+    goals: {
+      getGoalsSuggestions: async (req) => {
+        calls.push(req);
+        if (answer instanceof Error) throw answer;
+        return answer;
+      },
+    },
+  });
+  return { client, calls };
+}
+
+const SUGGESTED = {
+  ok: true,
+  data: { suggestions: [{ id: 1000071, title: 'Idea routing', score: 7, matched_terms: ['triage', 'goal'] }] },
+};
+
+await test('BEHAVIOUR: a junk stored hint is ignored, not turned into goalId NaN', async () => {
+  for (const junk of ['not-an-id', '', '0', '-3', '4.5', {}]) {
+    const { client, calls } = stubClient(SUGGESTED);
+    const r = await triage.resolveGoalDefault({ suggested_goal_id: junk, title: 't' }, 'BV1', { client });
+    assert.notEqual(r.source, 'hint', `${JSON.stringify(junk)} is not a usable hint`);
+    assert.equal(calls.length, 1, 'and it falls through to the suggester rather than dead-ending');
+  }
+});
+
+await test('BEHAVIOUR: a stored hint wins and the suggester is never even called', async () => {
+  const { client, calls } = stubClient(SUGGESTED);
+  const r = await triage.resolveGoalDefault({ suggested_goal_id: 1000058, title: 'x' }, 'BV1', { client });
+  assert.equal(r.goalId, 1000058);
+  assert.equal(r.source, 'hint');
+  assert.equal(calls.length, 0, 'a named goal must not be re-derived — that is the whole point of the column');
+});
+
+await test('BEHAVIOUR: with no hint, the top suggestion becomes the default, labelled with its score', async () => {
+  const { client, calls } = stubClient(SUGGESTED);
+  const r = await triage.resolveGoalDefault({ title: 'goal triage routing', body_md: 'b' }, 'BV1', { client });
+  assert.equal(r.goalId, 1000071);
+  assert.equal(r.source, 'suggester');
+  assert.match(r.label, /score 7/);
+  assert.match(r.label, /triage\/goal/, 'the matched terms are what let the operator judge it');
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].query.version, 'BV1', 'goals are per-version — the wrong version offers an invalid home');
+  assert.equal(calls[0].query.limit, 3);
+});
+
+await test('BEHAVIOUR: the body is capped before it goes on a query string', async () => {
+  const { client, calls } = stubClient(SUGGESTED);
+  await triage.resolveGoalDefault({ title: 't', body_md: 'x'.repeat(9000) }, 'BV1', { client });
+  assert.equal(calls[0].query.body.length, 2000, 'an un-capped body would blow the URL length');
+});
+
+await test('BEHAVIOUR: a suggester THROW degrades to no default, it does not propagate', async () => {
+  const { client } = stubClient(new Error('ECONNREFUSED'));
+  const r = await triage.resolveGoalDefault({ title: 't' }, 'BV1', { client });
+  assert.deepEqual(r, { goalId: null, label: null, source: 'unavailable' },
+    'a triage verdict must survive the suggester being down');
+});
+
+await test('BEHAVIOUR: a non-ok or empty response is "none", distinct from "unavailable"', async () => {
+  const empty = await triage.resolveGoalDefault({ title: 't' }, 'BV1',
+    { client: stubClient({ ok: true, data: { suggestions: [] } }).client });
+  assert.equal(empty.source, 'none');
+  const notOk = await triage.resolveGoalDefault({ title: 't' }, 'BV1',
+    { client: stubClient({ ok: false, status: 500, data: null }).client });
+  assert.equal(notOk.source, 'none', 'the two are reported differently because the operator advice differs');
+});
+
+await test('BEHAVIOUR: blank ACCEPTS the default; only "-"/"none" declines', () => {
+  assert.deepEqual(triage.applyGoalAnswer(1000071, ''), { goalId: 1000071, warn: null });
+  assert.deepEqual(triage.applyGoalAnswer(1000071, '   '), { goalId: 1000071, warn: null },
+    'whitespace is a bare Enter, not a decision');
+  assert.deepEqual(triage.applyGoalAnswer(1000071, '-'), { goalId: null, warn: null });
+  assert.deepEqual(triage.applyGoalAnswer(1000071, 'none'), { goalId: null, warn: null });
+  assert.deepEqual(triage.applyGoalAnswer(1000071, 'NONE'), { goalId: null, warn: null });
+  assert.deepEqual(triage.applyGoalAnswer(1000071, '1000058'), { goalId: 1000058, warn: null },
+    'an explicit id overrides the default');
+});
+
+await test('BEHAVIOUR: junk clears the goal and SAYS SO rather than landing on a wrong one', () => {
+  for (const junk of ['abc', '12.5', '-4', '0', 'goal 7']) {
+    const r = triage.applyGoalAnswer(1000071, junk);
+    assert.equal(r.goalId, null, `"${junk}" must not resolve to a goal`);
+    assert.match(r.warn, /general bucket/, `"${junk}" must say where it will land instead`);
+  }
+  // Number('') is 0 and Number(' ') is 0 — both would silently become goal 0
+  // without the blank check above running first. Guarding the pair together.
+  assert.equal(triage.applyGoalAnswer(9, '').goalId, 9);
+});
+
+await test('BEHAVIOUR: createTask puts goal_id on the body, and omits it entirely when null', async () => {
+  const seen = [];
+  const fakeClient = {
+    tasks: { postTasks: async (req) => { seen.push(req.body); return { ok: true, data: { task: { id: 7 } } }; } },
+  };
+  const cliLib = require('../scripts/gds/cli-lib.js');
+  const realCliClient = cliLib.cliClient;
+  cliLib.cliClient = async () => fakeClient;
+  try {
+    // triage.js destructured cliClient at require time, so patching the module
+    // object cannot reach it — re-require in a fresh registry instead.
+    const fresh = freshTriage();
+    await fresh.createTask({ versionId: 'BV1', title: 't', description: 'd', priority: 3, sourceRef: 'idea:1', goalId: 1000071 });
+    await fresh.createTask({ versionId: 'BV1', title: 't', description: 'd', priority: 3, sourceRef: 'idea:2' });
+    assert.equal(seen[0].goal_id, 1000071, 'the goal must reach the server');
+    assert.ok(!('goal_id' in seen[1]),
+    'and opting out must send NO goal_id key — the server\'s catch-all only applies on absent');
+    assert.equal(seen[0].source, 'idea_inbox', 'provenance still travels');
+    assert.equal(seen[0].status, 'backlog');
+  } finally {
+    cliLib.cliClient = realCliClient;
+  }
+});
+
+await test('BEHAVIOUR: a failed create throws with the status, it does not return a phantom task', async () => {
+  const cliLib = require('../scripts/gds/cli-lib.js');
+  const realCliClient = cliLib.cliClient;
+  cliLib.cliClient = async () => ({
+    tasks: { postTasks: async () => ({ ok: false, status: 422, data: { error: 'NO_SUCH_GOAL' } }) },
+  });
+  try {
+    const fresh = freshTriage();
+    await assert.rejects(
+      () => fresh.createTask({ versionId: 'BV1', title: 't', description: 'd', goalId: 999999999 }),
+      /422/,
+    );
+  } finally {
+    cliLib.cliClient = realCliClient;
+  }
+});
+
+// ==========================================================================
+// STATIC — the surfaces a unit test cannot invoke (browser DOM strings, docs).
+// ==========================================================================
+
+// ---- 4. both paths send goal_id -------------------------------------------
+
+await test('BOTH PATHS: the CLI createTask and the hall payload each send goal_id', () => {
+  assert.match(TRIAGE, /if \(goalId != null\) body\.goal_id = Number\(goalId\);/,
+    'CLI: goal_id must reach the create body');
+  assert.match(TRIAGE, /async function createTask\(\{[^}]*goalId/,
+    'CLI: createTask must accept it rather than ignore the caller');
+  assert.match(HALL, /payload\.goal_id = Number\(form\.goal\.value\)/,
+    'hall: goal_id must reach the create payload');
+  assert.match(HALL, /data-goal-select/, 'hall: and there must be a picker to choose it from');
+});
+
+await test('BOTH PATHS: the stale "does not accept kind" note is corrected, not left to mislead', () => {
+  assert.ok(!/doesn't currently accept 'kind'/.test(TRIAGE),
+    'that claim was false — routes/tasks.js takes kind and the hall path sends it');
+  assert.match(TRIAGE, /no longer true/, 'and the correction says so explicitly');
+});
+
+// ---- 1. precedence: the stored hint wins ---------------------------------
+
+// (The CLI's precedence is proven by the BEHAVIOUR block above — it drives the
+// real function and asserts the suggester is never called on a hint. A source-shape
+// assertion here would only restate that, less reliably.)
+
+await test('PRECEDENCE: the hall picker marks the hint selected, and only auto-selects a suggestion without one', () => {
+  const fn = HALL.slice(HALL.indexOf('async function goalOptionsFor'), HALL.indexOf('async function renderPromote'));
+  assert.match(fn, /idea\.suggested_goal_id/, 'the hint is read');
+  assert.match(fn, /carried from the filing/, 'and labelled as inherited, not guessed');
+  assert.match(fn, /hint == null && i === 0 \? ' selected' : ''/,
+    'a suggestion is pre-selected ONLY when there is no hint to honour');
+});
+
+// ---- the suggester's weak-evidence signal is shown, not hidden -----------
+
+await test('the suggester default shows score + matched terms so it can be judged', () => {
+  assert.match(TRIAGE, /score \$\{top\.score\}/, 'CLI shows the score');
+  assert.match(TRIAGE, /matched_terms/, 'CLI shows why it matched');
+  assert.match(HALL, /matched: /, 'hall shows why it matched');
+  // task 1003062 documented that token overlap can match an incidental word; the
+  // visible score is what stops that being an invisible wrong default.
+  assert.match(HALL, /incidental word/, 'and the reason it is shown is written down');
+});
+
+// ---- 2. opting out is explicit ------------------------------------------
+
+await test('OPT-OUT: the prompt itself offers the way out, and the branch delegates the meaning', () => {
+  const branch = TRIAGE.slice(TRIAGE.indexOf('const gd = await resolveGoalDefault'), TRIAGE.indexOf('const task = await createTask'));
+  assert.match(branch, /general bucket/, 'the prompt has to say where opting out lands');
+  assert.match(branch, /applyGoalAnswer\(gd\.goalId, goalAns\)/,
+    'the branch must delegate to the tested helper, not re-implement the parsing inline');
+  assert.match(branch, /picked\.warn/, 'and surface its warning');
+  assert.match(branch, /resolveGoalDefault\(\{ \.\.\.idea, title \}, versionId\)/,
+    'the suggester must see the title the operator just confirmed, not the filed one');
+  // The semantics themselves are covered by the BEHAVIOUR block above — this
+  // only pins that main() is actually wired to them.
+});
+
+await test('OPT-OUT: the hall names where opting out actually lands, and only defaults to it last', () => {
+  const fn = HALL.slice(HALL.indexOf('async function goalOptionsFor'), HALL.indexOf('async function renderPromote'));
+  // "— no goal —" would be a lie: the server files a goal_id-less create under
+  // the version's catch-all. The label has to say so.
+  assert.match(fn, /general bucket/);
+  assert.ok(!/— no goal —/.test(fn), 'the honest label replaced the misleading one');
+  assert.match(fn, /opts\.length === 0 \? ' selected' : ''/, 'the opt-out is the fallback, not the default');
+  assert.match(fn, /a choice rather than the silent default/, 'and the intent is stated');
+});
+
+await test('the CLI result line names the goal, or says the task fell into the general bucket', () => {
+  assert.match(TRIAGE, /goal \$\{goalId\}` : ', → general bucket'/,
+    'where it landed must be visible in the output, both ways');
+});
+
+// ---- 3. degrades, never blocks -----------------------------------------
+
+await test('DEGRADES: a suggester outage yields no default rather than throwing', () => {
+  const fn = TRIAGE.slice(TRIAGE.indexOf('async function resolveGoalDefault'), TRIAGE.indexOf('async function createTask'));
+  assert.match(fn, /catch \(_\) \{\s*return \{ goalId: null, label: null, source: 'unavailable' \}/,
+    'the CLI must swallow it and report unavailable');
+  assert.match(TRIAGE, /goal suggester unreachable/, 'and tell the operator what happened');
+  const hallFn = HALL.slice(HALL.indexOf('async function goalOptionsFor'), HALL.indexOf('async function renderPromote'));
+  assert.match(hallFn, /catch \(_\) \{ suggestions = \[\]; \}/, 'the hall must degrade to no suggestions');
+  assert.match(hallFn, /must not stop a triage verdict/, 'the reasoning is recorded');
+});
+
+await test('the hall guards the stored hint against a junk value reaching the DOM', () => {
+  const fn = HALL.slice(HALL.indexOf('async function goalOptionsFor'), HALL.indexOf('async function renderPromote'));
+  assert.match(fn, /Number\.isFinite\(raw\) && raw > 0 \? raw : null/,
+    'value="NaN" would be POSTed as a goal id');
+});
+
+await test('the hall degrades a DEAD SESSION to no suggestions instead of navigating away', () => {
+  const fn = HALL.slice(HALL.indexOf('async function goalOptionsFor'), HALL.indexOf('async function renderPromote'));
+  // getJSON without softAuth calls location.assign on a 401 — from a background
+  // fetch that would discard whatever the builder had typed into the form.
+  assert.match(fn, /softAuth: true/);
+});
+
+await test('DEGRADES: the hall re-fetches goals when the version changes, newest-wins', () => {
+  // Two quick version changes race; an out-of-order resolve would paint another
+  // version's goals, all of which the server would reject.
+  assert.match(HALL, /var mine = \+\+goalFetch;/);
+  assert.match(HALL, /if \(mine !== goalFetch\) return;/);
+  // Goals belong to a version; keeping stale options would offer a home the
+  // server would reject.
+  assert.match(HALL, /vsel\.addEventListener\('change'/);
+  assert.match(HALL, /await goalOptionsFor\(vsel\.value\)/);
+});
+
+await test('the CLI uses the GENERATED typed client method, not the raw escape hatch', () => {
+  assert.match(TRIAGE, /api\.goals\.getGoalsSuggestions\(/,
+    'so a path or param rename reds the client build instead of failing at runtime');
+});
+
+// ---- the skill contract ------------------------------------------------
+
+await test('SKILL DOC: the inbox is declared homeless-only, with both consequences spelled out', () => {
+  assert.match(SKILL, /HOMELESS-ONLY/, 'the contract is stated');
+  assert.match(SKILL, /Every promote names a goal/, 'consequence 1');
+  assert.match(SKILL, /general` goal/, 'and it is honest about what opting out means');
+  assert.match(SKILL, /inherited, not guessed/, 'consequence 2 — precedence');
+  assert.match(SKILL, /0183/, 'and why a goal-less task now matters more than it used to');
+  assert.match(SKILL, /HOMELESS/i, 'the description line carries it too');
+});
+
+summary();