@bongos/core 1.19.841 → 1.19.843

package/scripts/gds/backfill-disciplines.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// scripts/gds/backfill-disciplines.js — task 1002988: give every role-less task a craft.
+//
+// WHY THIS EXISTS SEPARATELY FROM THE MIGRATION. core_247 narrows
+// tasks_discipline_check to {engineer, artist, ideator, ui} and carries a
+// last-resort `UPDATE ... SET discipline='engineer'` so a fresh install can never
+// be blocked on a human remembering to run a script. But that net is a blunt
+// guess. The real classification is classifyTaskDiscipline() — a JS heuristic over
+// title + description + touches that SQL cannot express — so the good pass runs
+// here, first, and the migration only catches what is left.
+//
+// Run this BEFORE deploying core_247. Order matters: rows this script resolves keep
+// a reasoned craft; rows it does not are parked on 'engineer' by the migration.
+//
+// USAGE
+//   node scripts/gds/backfill-disciplines.js              # dry run — the spot-check list
+//   node scripts/gds/backfill-disciplines.js --apply      # commit the PATCHes
+//   node scripts/gds/backfill-disciplines.js --sample 40  # widen the printed sample
+//
+// The dry run is the default on purpose: the task required a spot-check list for the
+// owner BEFORE anything was applied, and 1,189 rows is not a diff anyone reviews in
+// their head.
+
+'use strict';
+
+const { cliClient, requireSession } = require('./cli-lib');
+const { resolveWriteDiscipline, WRITABLE_DISCIPLINES } = require('../../modules/lifecycle/task-classifier.js');
+
+// Rows whose title marks them as test debris. The classifier already skips these
+// (they are not real work), but they still carry 'unclassified' and therefore still
+// violate the narrowed constraint — so they must be resolved, not skipped, or the
+// migration's net silently becomes the thing that handles 164 rows.
+const SMOKE_RE = /__smoke__/;
+
+// The fallback for anything the heuristic refuses. Stated as a constant with its
+// reasoning rather than inlined, because this value is a GUESS and every report
+// below labels it as one.
+const FALLBACK = 'engineer';
+
+function classify(task) {
+  const resolved = resolveWriteDiscipline({
+    title: task.title, description: task.description, touches: task.touches,
+  });
+  if (resolved.discipline) {
+    return { discipline: resolved.discipline, reasoned: true, confidence: resolved.confidence ?? null };
+  }
+  return { discipline: FALLBACK, reasoned: false, confidence: null };
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// PATCH one row, WAITING OUT the per-session rate limit rather than counting it as a
+// failure. The first run of this backfill treated a 429 as a failed row and stopped
+// having written 120 of 1,189 — the limiter was doing its job and the script was
+// reading "slow down" as "no". The server tells us how long to wait; honour it.
+// Re-running is safe either way: the query only returns rows still unclassified.
+async function patchWithBackoff(api, id, discipline, maxAttempts = 6) {
+  for (let attempt = 1; ; attempt += 1) {
+    const res = await api.tasks.patchTasksId({ id, body: { discipline } });
+    if (res.status !== 429 || attempt >= maxAttempts) return res;
+    const retryAfter = Number(res.data?.error?.details?.retry_after_seconds);
+    const waitMs = (Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : 2 ** attempt) * 1000;
+    console.log(`    rate limited — waiting ${Math.round(waitMs / 1000)}s (attempt ${attempt}/${maxAttempts - 1})`);
+    await sleep(waitMs + 500);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const apply = args.includes('--apply');
+  const sampleIdx = args.indexOf('--sample');
+  const sampleSize = sampleIdx >= 0 ? Number(args[sampleIdx + 1]) || 20 : 20;
+
+  await requireSession();
+  const api = await cliClient();
+
+  const r = await api.tasks.getTasks({ query: { discipline: 'unclassified' } });
+  if (!r.ok) {
+    console.error(`failed to read tasks (${r.status}):`, r.data);
+    process.exit(1);
+  }
+  const tasks = r.data?.tasks || [];
+  if (!tasks.length) {
+    console.log('Nothing to do — no task carries discipline=unclassified.');
+    return;
+  }
+
+  const plan = tasks.map((t) => ({ task: t, ...classify(t), smoke: SMOKE_RE.test(t.title || '') }));
+  const reasoned = plan.filter((p) => p.reasoned);
+  const guessed = plan.filter((p) => !p.reasoned);
+  const byDiscipline = {};
+  for (const p of plan) byDiscipline[p.discipline] = (byDiscipline[p.discipline] || 0) + 1;
+
+  console.log(`\n${apply ? 'Applying' : 'DRY RUN —'} discipline backfill over ${plan.length} role-less task(s)\n`);
+  console.log('  Resolved by the classifier (a reasoned answer):');
+  for (const [d, n] of Object.entries(byDiscipline).sort((a, b) => b[1] - a[1])) {
+    const reasonedN = reasoned.filter((p) => p.discipline === d).length;
+    console.log(`    ${d.padEnd(12)} ${String(reasonedN).padStart(5)}`);
+  }
+  console.log(`\n  BEST GUESS (classifier refused → ${FALLBACK}): ${guessed.length}`);
+  console.log(`    of which __smoke__ test debris:            ${guessed.filter((p) => p.smoke).length}`);
+  console.log('    These are NOT determined answers. A later reader must not treat');
+  console.log('    them as evidence that anyone classified the row (owner decision 2026-09-17).\n');
+
+  console.log(`  Spot-check sample — reasoned (first ${sampleSize}):`);
+  for (const p of reasoned.slice(0, sampleSize)) {
+    console.log(`    ${p.discipline.padEnd(9)} ${p.confidence != null ? `(${p.confidence.toFixed(2)})` : '      '}  ${String(p.task.title).slice(0, 72)}`);
+  }
+  console.log(`\n  Spot-check sample — GUESSED (first ${sampleSize}):`);
+  for (const p of guessed.filter((x) => !x.smoke).slice(0, sampleSize)) {
+    console.log(`    ${p.discipline.padEnd(9)}          ${String(p.task.title).slice(0, 72)}`);
+  }
+
+  if (!apply) {
+    console.log(`\nDry run — nothing was written. Re-run with --apply to commit.\n`);
+    return;
+  }
+
+  let ok = 0;
+  const failures = [];
+  for (const p of plan) {
+    const res = await patchWithBackoff(api, p.task.id, p.discipline);
+    if (res.ok) ok += 1;
+    else failures.push({ id: p.task.id, status: res.status, detail: JSON.stringify(res.data).slice(0, 160) });
+    if (ok % 100 === 0 && res.ok) console.log(`  … ${ok}/${plan.length}`);
+  }
+  console.log(`\nApplied: ${ok}/${plan.length}`);
+  if (failures.length) {
+    console.log(`Failed:  ${failures.length}`);
+    for (const f of failures.slice(0, 20)) console.log(`   #${f.id} → ${f.status} ${f.detail}`);
+    process.exitCode = 1;
+  }
+  // Report the residue against the same query, so the number quoted afterwards is
+  // measured rather than assumed.
+  const after = await api.tasks.getTasks({ query: { discipline: 'unclassified' } });
+  const left = after.ok ? (after.data?.tasks || []).length : null;
+  console.log(`Remaining unclassified: ${left == null ? '(re-read failed)' : left}`);
+}
+
+if (require.main === module) {
+  main().catch((e) => { console.error(e && e.message ? e.message : e); process.exit(1); });
+}
+
+module.exports = { classify, FALLBACK, SMOKE_RE };

package/scripts/gds/fitness-ratchets.js

@@ -197,14 +197,65 @@ function docMetrics() {
 
 // ---------- knip (CI-only, fail-open on infra) ----------
 
+// WHY A LOCAL knip IS REQUIRED BEFORE SCORING (task 1003987).
+//
+// `npx --no-install` does not only look in THIS project: it walks up the directory
+// tree. A git worktree has no node_modules of its own, so the lookup climbs out and
+// finds the main checkout's copy — the command succeeds, and the number it produces is
+// wrong in a specific, repeatable way.
+//
+// MEASURED, not inferred, on 2026-09-17 against one tree:
+//   main checkout (knip local)   -> 221
+//   worktree      (knip ambient) -> 222, the extra being `binaries: package.json knip`
+// Diffed by name, the exports lists were IDENTICAL (221 both sides). knip was
+// reporting ITSELF as an unlisted binary, because from the worktree's point of view it
+// is not a declared dependency of anything resolvable.
+//
+// So the ratchet failed CLOSED on a phantom: 222 > baseline 221, on a tree whose real
+// findings had not moved. That cost a full elimination pass on task 1003848, where the
+// count was the loudest signal pointing away from the actual defect.
+//
+// This module's contract is fail-OPEN on infrastructure and fail-CLOSED on findings.
+// A count measured through an ambient knip is an infrastructure artefact, not a
+// finding, so it must not be scored at all. CI is unaffected: `npm ci` puts knip in
+// the project's own node_modules, which is exactly what this checks for.
+//
+// The row also offered "compare findings by NAME" as the fuller cure. That is a
+// baseline-format change (one integer today) and is deliberately NOT done here; naming
+// the unresolvable case is the "at minimum" it asked for, and it removes the false
+// failure without pretending the count is now environment-proof.
+function localKnipPath() {
+  for (const rel of ['node_modules/knip/package.json', 'node_modules/.bin/knip']) {
+    const p = path.join(ROOT, rel);
+    try { if (fs.existsSync(p)) return p; } catch { /* unreadable → treat as absent */ }
+  }
+  return null;
+}
+
+// Why the last knip score was skipped, or null when it was scored. Module-scoped so
+// the caller can NAME the cause instead of printing one generic line for every
+// unrelated reason knip might not run.
+let knipSkipReason = null;
+function lastKnipSkipReason() { return knipSkipReason; }
+
 function knipIssueCount() {
+  knipSkipReason = null;
+  if (!localKnipPath()) {
+    // Not "knip is missing" — an ambient one may well run. The point is that its
+    // answer is not comparable to the baseline, which was measured with a local one.
+    knipSkipReason = `no knip in ${path.join(ROOT, 'node_modules')} — `
+      + 'npx would resolve one from outside this tree and report it as an unlisted '
+      + 'binary, scoring one higher than the same code scores in CI (task 1003987)';
+    return null;
+  }
   let raw;
   try {
     raw = execSync('npx --no-install knip --reporter json --no-exit-code', {
       cwd: ROOT, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'],
     });
   } catch (e) {
-    if (e && e.stdout) raw = e.stdout.toString(); else return null; // knip unavailable → skip
+    if (e && e.stdout) { raw = e.stdout.toString(); }
+    else { knipSkipReason = `npx knip failed to run in ${ROOT}`; return null; }
   }
   try {
     const j = JSON.parse(raw);
@@ -219,6 +270,7 @@ function knipIssueCount() {
     }
     return files + items;
   } catch {
+    knipSkipReason = 'knip produced output this script could not parse as JSON';
     return null;
   }
 }
@@ -426,7 +478,10 @@ function main() {
   if (knipOnly) {
     const value = knipIssueCount();
     if (value === null) {
-      console.warn('fitness-ratchets: WARN — knip not runnable here (no node_modules / npx failure); failing OPEN.');
+      // Name WHY (task 1003987). "not runnable here" sent readers looking for a
+      // broken install when the real answer was that the number would have been
+      // wrong — a different problem with a different fix.
+      console.warn(`fitness-ratchets: WARN — knip not scored: ${lastKnipSkipReason() || 'knip unavailable'}; failing OPEN.`);
       process.exit(0);
     }
     const { metrics: knipBaselines, error: knipBaselineError } = readBaselines();
@@ -466,6 +521,8 @@ module.exports = {
   consoleCallCount,
   isServerPath,
   knipIssueCount,
+  localKnipPath,
+  lastKnipSkipReason,
   OVERSIZE_LINES,
   WINDOW,
   BASELINE_PATH,

package/scripts/gds/init.js

@@ -763,7 +763,12 @@ async function seedViaApi(spec, { dryRun, log = console.log, api = apiCall } = {
   // 2. starter task(s) — linked to the first goal so /status rolls them up
   let created = 0;
   for (const t of starters) {
-    if (await postTask(t, { kind: t.kind || 'unclassified', discipline: undefined, criterion_ids: [criterionId] })) created++;
+    // task 1002988: `discipline: undefined` used to sit in this extras object, and
+    // because `...extra` spreads AFTER postTask's own `t.discipline || 'engineer'`
+    // it clobbered that default back to nothing — which is why a freshly scaffolded
+    // instance was born with role-less starter tasks. Dropped, so starters inherit
+    // the same default every other seeded task already got.
+    if (await postTask(t, { kind: t.kind || 'unclassified', criterion_ids: [criterionId] })) created++;
   }
   // 3. kickoff steps as tracked tasks
   for (const t of kickoff) {

package/scripts/gds/triage.js

@@ -59,6 +59,7 @@ const readline = require('node:readline');
 const fs = require('node:fs');
 const { cliClient, requireSession } = require('./cli-lib');
 const { resolveDefaultVersion } = require('./version-select.js');
+const { resolveWriteDiscipline } = require('../../modules/lifecycle/task-classifier.js');
 
 function prompt(rl, question) {
   return new Promise((resolve) => rl.question(question, (a) => resolve(a)));
@@ -276,6 +277,12 @@ async function createTask({ versionId, title, description, priority, sourceRef,
     priority: priority ?? null,
     source: 'idea_inbox',
     source_ref: sourceRef ?? null,
+    // task 1002988: the server now refuses a task whose craft it cannot infer, and
+    // a 400 in the middle of an interactive triage loop would cost the operator the
+    // promotion they just decided on. So resolve it here with the SAME function the
+    // server uses, and name a fallback rather than letting the loop break — the
+    // identical trade modules/ideas/inbox.js makes for capture.
+    discipline: resolveWriteDiscipline({ title, description }).discipline || 'engineer',
   };
   if (goalId == null) {
     throw new Error('createTask: goal_id is required — every task belongs to a goal (task 1003598 deleted the catch-all fallback).');

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.841'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.843'; // 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_roster.mjs

@@ -0,0 +1,132 @@
+// tests/agents_roster.mjs — the SHIPPED roster in `.claude/agents/` (task
+// 1002496, goal 1000095).
+//
+// The definitions are prose files, so nothing about them is checked by the type
+// system, and the sync that imports them is fail-open at deploy (a bad file makes
+// the registry smaller, never aborts the deploy — tests/agents_sync.mjs pins
+// that). The consequence is that a malformed definition is INVISIBLE until
+// someone goes looking in the registry for an agent that quietly never imported.
+// This file is the guard: every roster file must survive the REAL parser and the
+// REAL validator, not a hand-built object that resembles one.
+//
+// Tested at the round-trip altitude on purpose. A test over parseAgentFile alone
+// passes on a key the validator later drops, which is exactly the defect task
+// 1004007 records: a top-level `touches:` validates ok and is silently normalized
+// away. Parse and validate together, or the test agrees with the bug.
+//
+// In tests/ rather than modules/agents/tests/ for the same reason as
+// tests/agents_sync.mjs: the module is default:false and module-local tests are
+// discovered only when the module is ENABLED, so they would never run here.
+//
+// Run:  node tests/agents_roster.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const sync = require('../scripts/gds/agents-sync.js');
+const validate = require('../modules/agents/lib/validate.js');
+
+const validateDefinition = validate.validateAgentDefinition || validate;
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); console.log(`  PASS  ${name}`); passed += 1; }
+  catch (err) { console.log(`  FAIL  ${name}\n        ${err.message}`); failed += 1; }
+}
+
+const ROSTER_DIR = new URL('../.claude/agents/', import.meta.url);
+const files = fs.readdirSync(ROSTER_DIR)
+  .filter((f) => f.endsWith('.md'))
+  .sort();
+
+// Parse once, reuse across the cases below. The name comes from the FILENAME,
+// which is how agents-sync identifies a file-sourced definition.
+const roster = files.map((f) => {
+  const name = f.replace(/\.md$/, '');
+  const text = fs.readFileSync(new URL(f, ROSTER_DIR), 'utf8');
+  return { name, file: f, candidate: sync.parseAgentFile(text, { name }) };
+});
+
+console.log('every shipped definition survives parse + validate:');
+
+// An empty roster would pass every per-file assertion below by vacuity — the
+// failure mode where a green suite means "nothing ran". Pin the floor.
+t('the roster is not empty', () => {
+  assert.ok(roster.length > 0, '.claude/agents/ holds no definitions — a vacuous pass');
+});
+
+for (const { name, file, candidate } of roster) {
+  t(`${file} validates against the real validator`, () => {
+    // authorRank archon so a scoped definition is judged on its shape rather
+    // than refused for rank; allowedModules mirrors what the sync passes.
+    const verdict = validateDefinition(candidate, {
+      authorRank: 'archon',
+      allowedModules: ['agents'],
+      protectedModules: [],
+    });
+    assert.ok(
+      verdict.ok,
+      `${file} would not import: ${JSON.stringify(verdict.errors)}`,
+    );
+  });
+
+  t(`${file} carries a persona worth sending`, () => {
+    // The BODY is the persona, and it is sent to a paid model on every fire. A
+    // file whose frontmatter parsed but whose body did not is the quiet failure
+    // this catches — it validates as a string and says nothing.
+    const persona = String(candidate.persona || '');
+    assert.ok(persona.length > 200, `${file}: persona is ${persona.length} chars — too thin to be a role prompt`);
+    assert.match(persona, new RegExp(name.replace(/-/g, '[- ]')), `${file}: the persona never names the agent it defines`);
+  });
+}
+
+console.log('\nthe on-demand roster this task shipped:');
+
+t('historian, planner and onboarding-buddy are all present', () => {
+  const names = roster.map((r) => r.name);
+  for (const want of ['historian', 'planner', 'onboarding-buddy']) {
+    assert.ok(names.includes(want), `${want} is missing from the roster`);
+  }
+});
+
+t('each of the three is on-demand', () => {
+  for (const want of ['historian', 'planner', 'onboarding-buddy']) {
+    const entry = roster.find((r) => r.name === want);
+    assert.equal(entry.candidate.trigger_type, 'on-demand',
+      `${want} must be on-demand — an event trigger here would fire on ships nobody asked it about`);
+  }
+});
+
+console.log('\nthe trap an event definition would walk into:');
+
+// TRIPWIRE for task 1004007, and the reason it is HERE rather than in that task:
+// this directory is where the mistake gets made. A file cannot express
+// `trigger_spec.touches` today (agents-sync.js parses a flat frontmatter and
+// folds only `event:` into the spec), and event-router.js:168 reads an absent
+// filter as FIRES ON EVERY SHIP at roughly $0.90 a fire. So the first
+// file-authored event agent is a standing bill, silently.
+//
+// This reds the moment someone adds one, which is the moment the warning is
+// worth something. Once 1004007 lands, tighten it to assert the filter SURVIVED
+// into trigger_spec rather than refusing event definitions outright.
+t('no file-authored event agent until a file can declare its filter', () => {
+  const eventBacked = roster.filter((r) => r.candidate.trigger_type === 'event');
+  for (const entry of eventBacked) {
+    const spec = entry.candidate.trigger_spec;
+    const globs = spec && Array.isArray(spec.touches) ? spec.touches
+      : spec && Array.isArray(spec.touches_globs) ? spec.touches_globs
+        : [];
+    assert.ok(
+      globs.length > 0,
+      `${entry.file} is an event definition with no touches filter, so it would fire on EVERY ship (~$0.90 each). `
+      + 'A file cannot declare one until task 1004007 lands — see tests/agents_roster.mjs.',
+    );
+  }
+});
+
+console.log(`\nagents_roster: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/knip_ratchet_ambient.mjs

@@ -0,0 +1,101 @@
+// tests/knip_ratchet_ambient.mjs — the knip ratchet refuses to score through an
+// ambient knip, instead of failing CLOSED on a number it cannot compare (task 1003987).
+//
+// THE DEFECT. `npx --no-install` walks UP the directory tree. A git worktree has no
+// node_modules of its own, so the lookup climbs out to the main checkout and succeeds —
+// and knip, unable to resolve itself as a declared dependency of the tree it is
+// scanning, reports ITSELF as an unlisted binary.
+//
+// MEASURED on one tree, 2026-09-17:
+//   main checkout (knip local)   -> 221, PASS
+//   worktree      (knip ambient) -> 222, FAIL against baseline 221
+// The extra was `binaries: package.json knip`. Diffed BY NAME the exports lists were
+// identical — 221 both sides. Nothing about the code had moved.
+//
+// That false red cost a full elimination pass on task 1003848: the count was the
+// loudest signal on the board and it pointed away from the real defect.
+//
+// The module's contract is fail-OPEN on infrastructure, fail-CLOSED on findings. A
+// count taken through an ambient knip is an infrastructure artefact, so it must not be
+// scored. CI is unaffected — `npm ci` puts knip in the project's own node_modules.
+//
+// Run:  node --test tests/knip_ratchet_ambient.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ratchets = require('../scripts/gds/fitness-ratchets.js');
+const SRC = readFileSync(path.join(REPO_ROOT, 'scripts/gds/fitness-ratchets.js'), 'utf8');
+
+test('the local-knip check runs BEFORE npx, so an ambient knip is never scored', () => {
+  const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));
+  const body = fn.slice(0, fn.indexOf('\n}\n'));
+  const guard = body.indexOf('localKnipPath()');
+  const spawn = body.indexOf('execSync(');
+  assert.ok(guard > 0 && spawn > 0, 'both the guard and the spawn must be present');
+  assert.ok(guard < spawn,
+    'checking after spawning would score the ambient count first — the whole bug');
+});
+
+test('it returns null (skip) rather than a number when knip is not local', () => {
+  // The fail direction matters: a number here is compared against a baseline measured
+  // with a LOCAL knip, so returning one is worse than returning nothing.
+  const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));
+  const body = fn.slice(0, fn.indexOf('\n}\n'));
+  assert.match(body, /if \(!localKnipPath\(\)\)[\s\S]{0,600}return null;/,
+    'the unresolvable case must skip, not score');
+});
+
+test('the skip NAMES its cause — a generic line sent readers hunting a broken install', () => {
+  assert.equal(typeof ratchets.lastKnipSkipReason, 'function');
+  ratchets.knipIssueCount();
+  const reason = ratchets.lastKnipSkipReason();
+  // In this repo the test runs where knip IS local (CI, main checkout), so the reason
+  // is null; where it is NOT local the reason must be specific. Assert whichever case
+  // this machine is in, so the test is meaningful on both.
+  if (ratchets.localKnipPath()) {
+    assert.equal(reason, null, 'a scored run must not claim it was skipped');
+  } else {
+    assert.ok(reason && /knip/i.test(reason), 'the skip must say what was missing');
+    assert.match(reason, /node_modules/, 'and where it looked');
+  }
+});
+
+test('localKnipPath finds a knip that IS local, and reports none when it is not', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'knipprobe-'));
+  try {
+    // The predicate is about THIS repo's root, so prove it against the real answer
+    // rather than a reimplementation: it must agree with the filesystem.
+    const expected = ['node_modules/knip/package.json', 'node_modules/.bin/knip']
+      .some((rel) => fs.existsSync(path.join(REPO_ROOT, rel)));
+    assert.equal(!!ratchets.localKnipPath(), expected,
+      'localKnipPath must agree with what is actually on disk');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('the caller fails OPEN on a skip — an unscorable metric is not a violation', () => {
+  assert.match(SRC, /knip not scored: \$\{lastKnipSkipReason\(\)/,
+    'the warning must carry the specific reason');
+  const warnIdx = SRC.indexOf('knip not scored:');
+  const after = SRC.slice(warnIdx, warnIdx + 300);
+  assert.match(after, /process\.exit\(0\)/,
+    'a skip must exit 0 — failing closed here is what this task removed');
+});
+
+test('a REAL regression still fails closed — the fix narrows nothing', () => {
+  // Guard against "fixed" by making the whole metric advisory.
+  const knipOnly = SRC.slice(SRC.indexOf('if (knipOnly)'));
+  const block = knipOnly.slice(0, knipOnly.indexOf('return;'));
+  assert.match(block, /violations\.length/, 'violations must still be evaluated');
+  assert.match(block, /process\.exit\(1\)/, 'and still fail the gate when present');
+});

package/tests/rank_floor_wiring.mjs

@@ -52,6 +52,10 @@ async function createdFloor({ scopeModules, needsMigration = false, requiresRank
   await createTask({
     versionId: 'BONGOS-V2',
     title: 'a task',
+    // Stated rather than inferred (task 1002988): createTask now refuses a craft it
+    // cannot work out, and "a task" says nothing. This fixture is about the RANK
+    // FLOOR, so it should not be at the mercy of the discipline heuristic.
+    discipline: 'engineer',
     goalId: '1000111',
     needsMigration,
     requiresRank,

package/tests/reward_gate.mjs

@@ -210,7 +210,7 @@ async function withStubbedCreatePool(run) {
 
 t('a task CREATED with NO reward is born with a positive, capped value', async () => {
   await withStubbedCreatePool(async (captured) => {
-    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', kind: 'feature', estMinutes: 40 });
+    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 40 });
     assert.ok(captured.creditsReward > 0, 'INSERT must bind a positive credits_reward');
     assert.equal(captured.creditsReward, 40, 'feature @40min -> 40 drachmae');
     assert.ok(captured.creditsReward <= db.REWARD_SUGGESTION_CAP, 'must respect the cap');
@@ -220,7 +220,7 @@ t('a task CREATED with NO reward is born with a positive, capped value', async (
 
 t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', creditsReward: 0, kind: 'bug', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 0, kind: 'bug', estMinutes: 40 });
     // bug weight 1.25 -> 50; 0 is treated as "unset" so the default kicks in.
     assert.equal(captured.creditsReward, 50);
   });
@@ -228,14 +228,14 @@ t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', a
 
 t('a huge-est new task is CAPPED at creation, not ballooned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', kind: 'feature', estMinutes: 9999 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 9999 });
     assert.equal(captured.creditsReward, db.REWARD_SUGGESTION_CAP);
   });
 });
 
 t('an EXPLICIT positive credits_reward is PRESERVED (never overridden)', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', creditsReward: 17, kind: 'feature', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 17, kind: 'feature', estMinutes: 40 });
     assert.equal(captured.creditsReward, 17, 'author-set positive value must survive untouched');
   });
 });