@bongos/core 1.19.383 → 1.19.385

package/tests/fitness.mjs

@@ -354,6 +354,124 @@ test('migration-namespacing actually CATCHES a cross-source stem collision (the
   assert.equal(collisions[0].stem, '188_x');
 });
 
+// --- Check 31: ADR numbers unique + index agrees with the tree (task 1003164 / ADR 0195) ---
+//
+// The ADR half of Check 11b's guard. The fixture is the REAL collision: on 2026-08-22 two
+// branches each landed an ADR numbered 0181 under different slugs, so git saw no path
+// collision, README.md auto-merged into two rows, and every gate passed.
+
+const adrNs = require(path.join(ROOT, 'scripts', 'gds', 'adr-namespace.js'));
+
+test('ADR numbering: the live tree is clean (all 20 known duplicates grandfathered)', () => {
+  const r = fitness.checkAdrNumbering();
+  assert.equal(r.hardFail, false, r.violations.join('\n'));
+  assert.match(r.note, /ADR file\(s\)/, 'note reports the file + row counts');
+});
+
+test('ADR numbering actually CATCHES two ADRs sharing a number (the 0181 pair, not a no-op gate)', () => {
+  const collisions = adrNs.numberCollisions([
+    '0180-dependency-intake-and-drift-policy.md',
+    '0181-ship-requires-an-assurance.md',
+    '0181-teardown-state-gate-and-address-retention.md',
+    '0182-something-else.md',
+  ]);
+  assert.equal(collisions.length, 1, 'the shared number must be reported exactly once');
+  assert.equal(collisions[0].number, '0181');
+  assert.deepEqual(collisions[0].files, [
+    '0181-ship-requires-an-assurance.md',
+    '0181-teardown-state-gate-and-address-retention.md',
+  ], 'BOTH paths are named — the report has to say which two files to look at');
+});
+
+test('ADR numbering: a grandfathered pair passes, but a THIRD file on that number does not', () => {
+  const pair = adrNs.LEGACY_DUPLICATE_ADRS['0008'];
+  assert.equal(pair.length, 2, 'fixture: 0008 is a known legacy pair');
+
+  // the exact frozen pair is exempt
+  assert.deepEqual(adrNs.numberCollisions([...pair]), [], 'the frozen legacy pair must pass');
+
+  // a third file joining the number is NOT — the exemption is set-equality, not "number 0008 is free"
+  const third = adrNs.numberCollisions([...pair, '0008-a-brand-new-adr.md']);
+  assert.equal(third.length, 1, 'a third file on a grandfathered number must still be flagged');
+  assert.equal(third[0].files.length, 3);
+
+  // so is a RENAME of either half — schema-migrations-style, the frozen names are the exemption
+  const renamed = adrNs.numberCollisions([pair[0].replace('.md', '-v2.md'), pair[1]]);
+  assert.equal(renamed.length, 1, 'renaming half of a grandfathered pair un-grandfathers it');
+});
+
+test('ADR numbering: the index must have one row per file, pointing at a file that exists', () => {
+  const files = ['0001-a.md', '0002-b.md'];
+  const row = (n, slug) => `| ${n} | [Title](${n}-${slug}.md) | topic |`;
+
+  // clean: one row per file, every row resolves
+  const clean = adrNs.indexViolations({
+    basenames: files,
+    rows: adrNs.parseIndexRows([row('0001', 'a'), row('0002', 'b')].join('\n')),
+  });
+  assert.deepEqual(clean, [], 'a matching index must pass: ' + clean.join('; '));
+
+  // DANGLING row — a row for a number with no file (the other half of the collision problem:
+  // the 2026-08-22 renumber had to reposition a row by hand)
+  const dangling = adrNs.indexViolations({
+    basenames: files,
+    rows: adrNs.parseIndexRows([row('0001', 'a'), row('0002', 'b'), row('0003', 'ghost')].join('\n')),
+  });
+  assert.equal(dangling.length, 1, 'exactly one violation for the dangling row');
+  assert.match(dangling[0], /does not exist/, 'the message names the missing file');
+  assert.match(dangling[0], /0003-ghost\.md/);
+
+  // DUPLICATED row — what an auto-merged index leaves behind (the live 0116/0117 case)
+  const dupe = adrNs.indexViolations({
+    basenames: files,
+    rows: adrNs.parseIndexRows([row('0001', 'a'), row('0002', 'b'), row('0002', 'b')].join('\n')),
+  });
+  assert.equal(dupe.length, 1);
+  assert.match(dupe[0], /has 2 index rows/, 'the message counts the rows and names their lines');
+
+  // UNINDEXED file — how a collision hides: the second file of a colliding pair is the one
+  // that never gets a row, so `ls docs/adr/` and the index quietly disagree
+  const missing = adrNs.indexViolations({
+    basenames: [...files, '0003-unindexed.md'],
+    rows: adrNs.parseIndexRows([row('0001', 'a'), row('0002', 'b')].join('\n')),
+  });
+  assert.equal(missing.length, 1);
+  assert.match(missing[0], /has no row in docs\/adr\/README\.md/);
+});
+
+test('ADR numbering: a row is read by its OWN-number link, so citing other ADRs in the prose is fine', () => {
+  // Index rows routinely cite sibling ADRs inside the title cell. Only the link whose
+  // filename starts with the row's own number is the row's subject.
+  const rows = adrNs.parseIndexRows(
+    '| 0100 | [Two-repo model, superseding [0099](0099-old.md) and see [0101](0101-next.md)](0100-two-repo.md) | topic |',
+  );
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].target, '0100-two-repo.md', 'the own-number link is the row subject');
+  assert.deepEqual(
+    adrNs.indexViolations({ basenames: ['0100-two-repo.md'], rows }),
+    [], 'citing other ADRs in a row must not be read as extra rows',
+  );
+});
+
+test('ADR numbering: out-of-order rows WARN and never hard-fail (inherited drift, not a PR author\'s doing)', () => {
+  const row = (n) => `| ${n} | [T](${n}-s.md) | topic |`;
+  assert.deepEqual(adrNs.indexOrderWarnings(adrNs.parseIndexRows([row('0001'), row('0002')].join('\n'))), []);
+
+  const warns = adrNs.indexOrderWarnings(adrNs.parseIndexRows([row('0001'), row('0003'), row('0002')].join('\n')));
+  assert.equal(warns.length, 1, 'the backwards row is reported');
+  assert.match(warns[0], /ascending order/);
+
+  // and ordering contributes to `warnings`, never to `violations`
+  const live = fitness.checkAdrNumbering();
+  assert.equal(live.hardFail, false, 'the live index is out of order in places and must still pass');
+});
+
+test('ADR numbering: nextAdrNumber allocates above the highest number on disk', () => {
+  assert.equal(adrNs.nextAdrNumber(['0001-a.md', '0181-b.md', '0181-c.md']), 182, 'max + 1, duplicates included');
+  assert.equal(adrNs.nextAdrNumber([]), 1, 'an empty tree starts at 1');
+  assert.equal(adrNs.nextAdrNumber(['README.md', 'notes.txt']), 1, 'non-ADR files do not count');
+});
+
 // --- goal scope map imports PROTECTED_GLOBS (BV1.R54 / task 1508, ADR 0086 §7) ---
 
 test('scope map import check: the live module-scope-map.js passes', () => {

package/tests/grade_unavailable_display.mjs

@@ -35,6 +35,54 @@ test('grader-unavailable grade → "GRADER UNAVAILABLE", NOT a 0/10 FAIL or "fix
   assert.doesNotMatch(out, /blended .*\/10/, 'must NOT print a 0/10 quality score for a non-grade');
 });
 
+// ---------- task 1003313: the outage card says WHY ----------
+//
+// Before this, a total outage printed "GRADER UNAVAILABLE" and stopped — the
+// builder had no way to tell a logged-out CLI from a Windows alias stub from a
+// real API outage, and two builders stayed dark for days. The diagnostic and the
+// local `claude` CLI verdict are report-only: they never change the outcome.
+
+const OUTAGE = {
+  passed: false, score: 0, threshold: 6, notes_md: 'GRADER UNAVAILABLE — all 4/4 gating worker(s) failed to run',
+  rubric_scores: {}, issues: [],
+  signals: {
+    panel_outcome: 'unavailable',
+    workers: ['narc', 'quality', 'hacker', 'efficiency'].map((kind) => ({
+      kind, error: 'SUBAGENT_NONZERO_EXIT', exit_code: 1, stderr_tail: 'Invalid API key · Run /login',
+    })),
+  },
+};
+
+test('an outage card prints each dead worker with its exit code + CLI error (task 1003313)', () => {
+  const out = formatGradeOutcome(OUTAGE, 1003313);
+  assert.match(out, /GRADER UNAVAILABLE/);
+  assert.match(out, /What the grader subprocess actually did/);
+  assert.match(out, /narc\s+exit 1 — Invalid API key/, 'names the worker, its exit code, and what the CLI said');
+  assert.doesNotMatch(out, /Fix the issues above/, 'still not a quality rejection');
+});
+
+test('an outage card relays the injected claude-CLI preflight finding + its fix (task 1003313)', () => {
+  const out = formatGradeOutcome(OUTAGE, 1003313, {
+    level: 'warn', title: 'claude CLI',
+    detail: 'launches (2.1.0) but is not logged in',
+    fix: 'Run `claude login`',
+  });
+  assert.match(out, /Local `claude` CLI: launches \(2\.1\.0\) but is not logged in/);
+  assert.match(out, /Fix: Run `claude login`/);
+});
+
+test('a HEALTHY claude-CLI finding adds no noise to the outage card (task 1003313)', () => {
+  const out = formatGradeOutcome(OUTAGE, 1003313, { level: 'ok', title: 'claude CLI', detail: 'logged in' });
+  assert.doesNotMatch(out, /Local `claude` CLI/, 'an ok finding is not worth a line');
+});
+
+test('an outage from a pre-propagation server prints no empty diagnostic block (task 1003313)', () => {
+  const g = { ...OUTAGE, signals: { panel_outcome: 'unavailable', workers: [{ kind: 'narc', error: 'SUBAGENT_NONZERO_EXIT' }] } };
+  const out = formatGradeOutcome(g, 1003313);
+  assert.match(out, /GRADER UNAVAILABLE/);
+  assert.doesNotMatch(out, /What the grader subprocess actually did/);
+});
+
 test('a real FAIL still prints the FAIL block + fix-the-issues guidance (#943 regression guard)', () => {
   const g = {
     passed: false, score: 4, threshold: 6,

package/tests/grader_panel.mjs

@@ -246,6 +246,90 @@ await atest('graderUnavailableResult: server-compat shape (null axes, fallthroug
   assert.equal(r.passed, false);
 });
 
+// ---------- task 1003313: a dark panel names its own cause ----------
+//
+// The regression these pin: runWorker used to keep only err.code and throw away
+// err.exit_code / err.stderr, so a total outage stored four identical
+// SUBAGENT_NONZERO_EXIT rows and two builders sat dark for days with a 0/10 card
+// that could not say whether the CLI was logged out, aliased, or the API down.
+
+const workersMod = require('../modules/grading/grader-workers/index.js');
+const { runWorker, redactStderrTail, STDERR_TAIL_MAX } = workersMod;
+
+// A worker module stub: buildPrompt/extractJson/computeVerdict, no spawning.
+const STUB_WORKER = {
+  KIND: 'quality', NAME: 'Quality', SPECIALTY: 'stub',
+  buildPrompt: () => 'prompt',
+  extractJson: (s) => JSON.parse(s),
+  computeVerdict: (parsed, meta) => (meta.subprocess_error
+    ? { verdict: 'fail', scores: {}, issues: [], notes_md: '', confidence: 0, error: meta.subprocess_error }
+    : { verdict: 'pass', scores: { code_quality: 9 }, issues: [], notes_md: '', confidence: 0.9, error: null }),
+};
+
+// The exact error runSubagent throws on a nonzero exit.
+const nonzeroExit = ({ exitCode = 1, stderr = '', stdout = '' } = {}) =>
+  Object.assign(new Error(`subagent exited with code ${exitCode}`), {
+    code: 'SUBAGENT_NONZERO_EXIT', exit_code: exitCode, run_ms: 120, stdout, stderr,
+  });
+
+await atest('runWorker: a dead subprocess carries exit_code + stderr_tail onto the worker row (task 1003313)', async () => {
+  const r = await runWorker(STUB_WORKER, {
+    task: {}, diff: '', changedFiles: [], diffStats: {}, model: 'm', runOpts: {},
+    runSubagentFn: async () => { throw nonzeroExit({ exitCode: 1, stderr: 'Invalid API key · Run /login' }); },
+  });
+  assert.equal(r.error, 'SUBAGENT_NONZERO_EXIT');
+  assert.equal(r.exit_code, 1, 'the exit code must survive the catch');
+  assert.match(r.stderr_tail, /Invalid API key/, "the CLI's own error line must survive the catch");
+  assert.equal(r.retried, true, 'a transient error is still retried once (#465)');
+});
+
+await atest('runWorker: a clean run adds neither exit_code nor stderr_tail (task 1003313)', async () => {
+  const r = await runWorker(STUB_WORKER, {
+    task: {}, diff: '', changedFiles: [], diffStats: {}, model: 'm', runOpts: {},
+    runSubagentFn: async () => ({ stdout: '{"code_quality":9}', run_ms: 10, cost_usd: 0.5 }),
+  });
+  assert.equal(r.verdict, 'pass');
+  assert.equal('exit_code' in r, false, 'a healthy grade row keeps its existing shape');
+  assert.equal('stderr_tail' in r, false);
+});
+
+await atest('runWorker: stdout is the fallback when the CLI explained itself there (task 1003313)', async () => {
+  const r = await runWorker(STUB_WORKER, {
+    task: {}, diff: '', changedFiles: [], diffStats: {}, model: 'm', runOpts: {},
+    runSubagentFn: async () => { throw nonzeroExit({ exitCode: 1, stderr: '', stdout: 'Not logged in.' }); },
+  });
+  assert.match(r.stderr_tail, /Not logged in/);
+});
+
+test('redactStderrTail: strips secrets, strips ANSI, bounds the length (task 1003313)', () => {
+  assert.match(redactStderrTail('auth failed for sk-ant-api03-AbCdEf_12345'), /\[redacted\]/);
+  assert.doesNotMatch(redactStderrTail('token ghp_abcdefghijklmnopqrstuvwxyz0123'), /ghp_/);
+  assert.doesNotMatch(redactStderrTail('header Bearer eyJhbGciOiJIUzI1NiJ9.abc'), /eyJhbGci/);
+  assert.equal(redactStderrTail('\u001B[31mred error\u001B[0m'), 'red error', 'ANSI colour codes are stripped');
+  assert.equal(redactStderrTail('x'.repeat(STDERR_TAIL_MAX + 200)).length, STDERR_TAIL_MAX);
+  assert.equal(redactStderrTail('   '), null, 'an empty tail is null, not an empty string');
+  assert.equal(redactStderrTail(undefined), null);
+});
+
+test('aggregatePanel: the GRADER UNAVAILABLE verdict names exit code + CLI error (task 1003313)', () => {
+  const dead = (kind) => ({
+    kind, verdict: 'fail', error: 'SUBAGENT_NONZERO_EXIT', scores: {}, issues: [], confidence: 0,
+    exit_code: 1, stderr_tail: 'Invalid API key · Run /login',
+  });
+  const r = aggregatePanel([dead('narc'), dead('quality'), dead('hacker'), dead('efficiency')], {});
+  assert.equal(r.signals.panel_outcome, 'unavailable');
+  assert.match(r.notes_md, /GRADER UNAVAILABLE/);
+  assert.match(r.notes_md, /exit 1/, 'the verdict text must carry the exit code');
+  assert.match(r.notes_md, /Invalid API key/, 'the verdict text must carry the CLI error line');
+});
+
+test('aggregatePanel: no diagnostic appended when the workers carry none (pre-propagation grades)', () => {
+  const dead = (kind) => ({ kind, verdict: 'fail', error: 'SUBAGENT_NONZERO_EXIT', scores: {}, issues: [], confidence: 0 });
+  const r = aggregatePanel([dead('narc'), dead('quality'), dead('hacker'), dead('efficiency')], {});
+  assert.equal(r.signals.panel_outcome, 'unavailable');
+  assert.doesNotMatch(r.notes_md, /Diagnostic —/);
+});
+
 console.log(`${asyncPassed} passed, ${asyncFailed} failed (async)`);
 const totalFailed = failed + asyncFailed;
 console.log(`\n${passed + asyncPassed} passed, ${totalFailed} failed`);