@bongos/core 1.19.289 → 1.19.291

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

package/tests/pruned_lockfile_integrity.mjs

@@ -71,8 +71,8 @@ t('pruned lockfile: integrity hashes match the SOURCE lockfile verbatim (not rew
   assert.equal(mismatched.length, 0, `integrity rewritten for: ${mismatched.slice(0, 10).join(', ')}`);
 });
 
-t('CORE_DEP_NAMES: the pin domain is exactly the runtime core deps (express + pg)', () => {
-  assert.ok(Array.isArray(CORE_DEP_NAMES) && CORE_DEP_NAMES.includes('express') && CORE_DEP_NAMES.includes('pg'));
+t('CORE_DEP_NAMES: the pin domain is exactly the runtime core deps (express + pg + pino)', () => {
+  assert.ok(Array.isArray(CORE_DEP_NAMES) && CORE_DEP_NAMES.includes('express') && CORE_DEP_NAMES.includes('pg') && CORE_DEP_NAMES.includes('pino'));
 });
 
 console.log(`\npruned_lockfile_integrity: ${passed} passed, ${failed} failed`);