@bongos/core 1.19.287 → 1.19.289

package/tests/auto_satisfy_criteria.mjs

@@ -0,0 +1,212 @@
+// tests/auto_satisfy_criteria.mjs — task 1002069 / ADR 0183.
+//
+// A done-when criterion closes ITSELF once every gating task has shipped, and a
+// goal whose criteria are all satisfied flips open→achieved. The manual
+// /goal-review confirm stops being the only door (owner request 2026-07-05).
+//
+// What these tests actually protect, in order of how badly it would hurt:
+//
+//  1. THE DELIVERY GUARD, and the DELIBERATE ASYMMETRY around it. `abandoned` is
+//     terminal (task 1002651), so "no task is still pending" is TRUE for a
+//     criterion whose every linked task was CUT. Auto-closing on that alone would
+//     satisfy criteria on zero delivered work and cascade goals to `achieved`, so
+//     the auto-close SQL additionally requires >=1 SHIPPED.
+//     The review flag does NOT get that guard, on purpose. `pending_review` means
+//     "a human should LOOK at this", and task 1002651 chose that an all-abandoned
+//     criterion surfaces there — its work was cut, so someone must decide whether
+//     the criterion still means anything. Auto-close is the narrower question.
+//     Everything that auto-closes was flagged; not everything flagged auto-closes.
+//     An earlier draft of this task "aligned" the two and broke that intent —
+//     tests/criterion_progress.mjs caught it. Do not re-align them.
+//  2. THE EXEC CONTRACT. The helper writes through the caller's `exec`, never a
+//     module pool, because shipTask passes its open transaction client — a
+//     rolled-back ship must not leave a goal achieved.
+//  3. THE CASCADE RULE. Mirrors db.achieveGoalIfComplete: open goals only, >=1
+//     criterion, zero unsatisfied. Re-derived from the table, not from the rows
+//     that closed in this call.
+//
+// DB-free: a fake exec records the SQL and returns scripted rows, which is the
+// right level for a pure-SQL helper — the shapes and the branching are the risk,
+// and a live Postgres would test Postgres.
+//
+// Run:  node tests/auto_satisfy_criteria.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 doneWhen = require('../modules/lifecycle/done-when.js');
+const { autoSatisfyShippedCriteria, isPendingReview, buildCriterionProgress } = doneWhen;
+const { test, summary } = makeRunner();
+
+// A fake exec: hands back queued result sets in order, recording every call.
+function fakeExec(...results) {
+  const calls = [];
+  return {
+    calls,
+    async query(sql, params) {
+      calls.push({ sql, params });
+      return results[calls.length - 1] || { rows: [] };
+    },
+  };
+}
+
+const CRIT = { id: 10, version_id: 'BONGOS-V1', criterion_id: 'c-one', criterion_md: 'x', goal_id: 77, satisfied_by_task_id: 5 };
+
+// ---- 1. the delivery guard, in all three derivations -----------------------
+
+await test('GUARD (sql): the update requires BOTH nothing-pending AND >=1 shipped', () => {
+  const src = readFileSync(new URL('../modules/lifecycle/done-when.js', import.meta.url), 'utf8');
+  const body = src.slice(src.indexOf('async function autoSatisfyShippedCriteria'));
+  assert.match(body, /HAVING count\(\*\) FILTER \(WHERE t\.status NOT IN \('shipped', 'abandoned'\)\) = 0/,
+    'nothing may still be pending');
+  assert.match(body, /AND count\(\*\) FILTER \(WHERE t\.status = 'shipped'\) >= 1/,
+    'THE GUARD: an all-abandoned gating set delivered nothing and must not close a criterion');
+});
+
+await test('ASYMMETRY (sql): the review queue deliberately does NOT carry the delivery guard', () => {
+  const src = readFileSync(new URL('../modules/lifecycle/done-when.js', import.meta.url), 'utf8');
+  const start = src.indexOf('async function listPendingReviewCriteria');
+  const body = src.slice(start, src.indexOf('async function criterionProgress', start));
+  assert.ok(body.length > 200, 'the slice must actually contain the function');
+  assert.match(body, /HAVING count\(\*\) FILTER \(WHERE t\.status NOT IN \('shipped', 'abandoned'\)\) = 0/);
+  assert.ok(!/status = 'shipped'\) >= 1/.test(body),
+    'task 1002651 intends an all-abandoned criterion to SURFACE for review; only auto-close is gated');
+});
+
+await test('ASYMMETRY (pure): isPendingReview stays the WIDER question — unchanged by this task', () => {
+  // An all-abandoned criterion still flags for review (1002651's intent) even
+  // though it will never auto-close. That gap is the feature, not a bug.
+  assert.equal(isPendingReview({ satisfied: false, linked: 1, unshipped: 0 }), true,
+    'all-abandoned still SURFACES — a human decides whether the criterion survives');
+  assert.equal(isPendingReview({ satisfied: false, linked: 2, unshipped: 1 }), false, 'still work pending');
+  assert.equal(isPendingReview({ satisfied: true, linked: 1, unshipped: 0 }), false, 'already confirmed');
+  assert.equal(isPendingReview({ satisfied: false, linked: 0, unshipped: 0 }), false, 'no linked tasks');
+});
+
+await test('ASYMMETRY (rollup): the /status rollup is untouched by this task', () => {
+  const row = (tid, status) => ({
+    cnum: 1, id: 10, criterion_id: 'c-cut', criterion_md: 'x', satisfied: false, goal_id: 1,
+    task_id: tid, task_title: 't', task_status: status,
+  });
+  const g = [{ id: 1, title: 'g', status: 'open', scope_modules: [] }];
+  const cut = buildCriterionProgress('V1', [row(301, 'abandoned')], 0, g);
+  assert.equal(cut.criteria[0].counts.remaining, 0, 'abandoned is not "remaining" (task 1002651)');
+  assert.equal(cut.criteria[0].pending_review, true, 'and it still flags for review — pinned in criterion_progress.mjs');
+  assert.equal(buildCriterionProgress('V1', [row(302, 'shipped')], 0, g).criteria[0].pending_review, true);
+});
+
+// ---- 2. the exec contract --------------------------------------------------
+
+await test('EXEC: every write goes through the caller-supplied exec (so a ship txn is atomic)', async () => {
+  const exec = fakeExec({ rows: [CRIT] }, { rows: [{ id: 77, title: 'g', version_id: 'BONGOS-V1', status: 'achieved' }] });
+  const out = await autoSatisfyShippedCriteria(exec, { taskId: 5 });
+  assert.equal(exec.calls.length, 2, 'one criterion update + one goal cascade');
+  assert.deepEqual(out.criteria, [CRIT]);
+  assert.deepEqual(out.goals.map((g) => g.id), [77]);
+  const src = readFileSync(new URL('../modules/lifecycle/done-when.js', import.meta.url), 'utf8');
+  const body = src.slice(src.indexOf('async function autoSatisfyShippedCriteria'), src.indexOf('module.exports'));
+  assert.ok(!/\bpool\.query\b/.test(body), 'must never reach for the module pool — that would escape the caller txn');
+});
+
+await test('EXEC: shipTask passes its transaction CLIENT, and the reconciler passes the pool', () => {
+  const db = readFileSync(new URL('../modules/lifecycle/db.js', import.meta.url), 'utf8');
+  // db.js is over the fitness oversize threshold, so the hook is ONE line there
+  // and its body lives in done-when.closeCompletedWorkForShip. What must hold is
+  // that the thing handed in is the txn client, not a pool.
+  assert.match(db, /closeCompletedWorkForShip\(client, taskId\)/,
+    'the ship hook must run on the txn client, not the pool');
+  const dw = readFileSync(new URL('../modules/lifecycle/done-when.js', import.meta.url), 'utf8');
+  assert.match(dw, /autoSatisfyShippedCriteria\(client, \{ taskId \}\)/, 'and it forwards that client through');
+  const rec = readFileSync(new URL('../modules/lifecycle/publish-reconciler.js', import.meta.url), 'utf8');
+  assert.match(rec, /autoSatisfyShippedCriteria\(exec, \{\}\)/, 'the sweep is UNSCOPED (no taskId)');
+});
+
+// ---- 3. scoping, cascade, idempotence -------------------------------------
+
+await test('SCOPED vs UNSCOPED: the taskId parameter is what narrows the candidate set', async () => {
+  const scoped = fakeExec({ rows: [] });
+  await autoSatisfyShippedCriteria(scoped, { taskId: 42 });
+  assert.deepEqual(scoped.calls[0].params, [42]);
+  assert.match(scoped.calls[0].sql, /\$1::bigint IS NULL OR c\.id IN/, 'one SQL serves both shapes');
+
+  const sweep = fakeExec({ rows: [] });
+  await autoSatisfyShippedCriteria(sweep, {});
+  assert.deepEqual(sweep.calls[0].params, [null], 'unscoped passes NULL, which disables the narrowing clause');
+});
+
+await test('NO-OP: nothing closed means no cascade query at all', async () => {
+  const exec = fakeExec({ rows: [] });
+  const out = await autoSatisfyShippedCriteria(exec, {});
+  assert.deepEqual(out, { criteria: [], goals: [] });
+  assert.equal(exec.calls.length, 1, 'must not run the goal cascade when no criterion moved');
+});
+
+await test('CASCADE: only OPEN goals, only with >=1 criterion and zero unsatisfied', async () => {
+  const exec = fakeExec({ rows: [CRIT] }, { rows: [] });
+  await autoSatisfyShippedCriteria(exec, { taskId: 5 });
+  const cascade = exec.calls[1].sql;
+  assert.match(cascade, /g\.status = 'open'/, 'never re-touch an achieved/archived goal');
+  assert.match(cascade, /EXISTS\s*\(SELECT 1 FROM done_when_criteria d WHERE d\.goal_id = g\.id\)/, 'an empty goal cannot auto-achieve');
+  assert.match(cascade, /NOT EXISTS \(SELECT 1 FROM done_when_criteria d WHERE d\.goal_id = g\.id AND NOT d\.satisfied\)/, 'every criterion must be satisfied');
+  assert.deepEqual(exec.calls[1].params, [[77]]);
+});
+
+await test('CASCADE: a criterion with no goal closes nothing (goal_id NULL completes no goal)', async () => {
+  const exec = fakeExec({ rows: [{ ...CRIT, goal_id: null }] });
+  const out = await autoSatisfyShippedCriteria(exec, { taskId: 5 });
+  assert.equal(exec.calls.length, 1, 'no cascade query for a goal-less criterion');
+  assert.deepEqual(out.goals, []);
+});
+
+await test('CASCADE: goal ids are deduped, so N criteria under one goal is ONE cascade', async () => {
+  const exec = fakeExec({ rows: [CRIT, { ...CRIT, id: 11, criterion_id: 'c-two' }] }, { rows: [] });
+  await autoSatisfyShippedCriteria(exec, {});
+  assert.deepEqual(exec.calls[1].params, [[77]], 'one goal id, not two');
+});
+
+await test('IDEMPOTENT: the candidate set reads only unsatisfied rows, so a re-run is a no-op', () => {
+  const src = readFileSync(new URL('../modules/lifecycle/done-when.js', import.meta.url), 'utf8');
+  const body = src.slice(src.indexOf('async function autoSatisfyShippedCriteria'), src.indexOf('module.exports'));
+  assert.match(body, /WHERE c\.satisfied = false/, 'this is what makes the every-tick sweep safe');
+});
+
+await test('a non-numeric taskId is rejected rather than silently becoming an unscoped sweep', async () => {
+  const exec = fakeExec({ rows: [] });
+  await assert.rejects(() => autoSatisfyShippedCriteria(exec, { taskId: 'oops' }), /must be numeric/);
+  assert.equal(exec.calls.length, 0, 'nothing ran');
+});
+
+// ---- the ship hook is best-effort, the sweep is the retry ------------------
+
+await test('the ship hook cannot fail a ship, and the sweep exists to retry it', async () => {
+  // Behavioural, not textual: a throwing exec must not propagate out of the hook.
+  const boom = { query: async () => { throw new Error('db exploded'); } };
+  const logged = [];
+  const line = await doneWhen.closeCompletedWorkForShip(boom, 5, (m) => logged.push(m));
+  assert.match(line, /auto-satisfy skipped \(sweep retries\)/, 'the failure is reported, not thrown');
+  assert.match(logged.join('\n'), /shipTask 5/, 'and it names the ship it happened on');
+  const rec = readFileSync(new URL('../modules/lifecycle/publish-reconciler.js', import.meta.url), 'utf8');
+  assert.match(rec, /runCriterionSweep\(deps\)\.catch\(/, 'the sweep is fire-and-forget on the tick, like runCostSweep');
+  assert.match(rec, /BACKLOG DRAIN/, 'and documents why it is not merely belt-and-braces');
+});
+
+await test('closeCompletedWorkForShip: silent on the common no-op, and logs what closed', async () => {
+  const quiet = [];
+  const none = await doneWhen.closeCompletedWorkForShip({ query: async () => ({ rows: [] }) }, 5, (m) => quiet.push(m));
+  assert.equal(none, null, 'nothing closed => nothing returned');
+  assert.deepEqual(quiet, [], 'and nothing logged — a ship that closes nothing stays quiet');
+
+  const loud = [];
+  let call = 0;
+  const exec = { async query() { call += 1; return call === 1 ? { rows: [CRIT] } : { rows: [{ id: 77, title: 'G' }] }; } };
+  const line = await doneWhen.closeCompletedWorkForShip(exec, 9, (m) => loud.push(m));
+  assert.match(line, /auto-satisfied criteria \[c-one\]/);
+  assert.match(line, /auto-ACHIEVED goals \[77 "G"\]/);
+  assert.match(loud[0], /shipTask 9/);
+});
+
+summary();

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();