@bongos/core 1.20.42 → 1.20.44

package/tests/skill_grader_health.mjs

@@ -1,8 +1,10 @@
-// tests/skill_grader_health.mjs — the /grader-health skill exists and covers
-// the four health axes from the grader-hardening evaluation §6 (task 1002656):
-// outage runs, pass-rate drift, cost anomalies, and stale model pins — reading
-// LIVE data surfaces, emitting exact --regrade remediation lines, and staying
-// read-only (describe, never confirm/flip — ADR 0158 §2; no approval step on anyone's ship — ADR 0162).
+// tests/skill_grader_health.mjs — the grader HEALTH check (once /grader-health, now
+// Part A of the merged /grade-sweep — task 1004471) covers the four health axes from
+// the grader-hardening evaluation §6 (task 1002656): outage runs, pass-rate drift,
+// cost anomalies, and stale model pins — reading LIVE data surfaces, emitting exact
+// --regrade remediation lines, and staying read-only (describe, never confirm/flip —
+// ADR 0158 §2; no approval step on anyone's ship — ADR 0162). /grader-health stays
+// typeable as a hidden alias.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { readFileSync, existsSync } from 'node:fs';
@@ -10,16 +12,22 @@ import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const SKILL = path.join(ROOT, '.claude', 'skills', 'grader-health', 'SKILL.md');
+const SKILL = path.join(ROOT, '.claude', 'skills', 'grade-sweep', 'SKILL.md');
+const ALIAS = path.join(ROOT, '.claude', 'skills', 'grader-health', 'SKILL.md');
 
 // .claude/skills is INSTANCE-materialized; a neutral core checkout carries none
 // (task 1002470) — skip there, same guard shape as file_map.mjs.
 const skillsDirExists = existsSync(path.join(ROOT, '.claude', 'skills'));
 
-test('/grader-health exists and covers the four health axes on live data', (t) => {
+// Part A of the merged file: from its heading to Part B.
+const partA = (md) => md.slice(md.indexOf('## Part A'), md.indexOf('## Part B'));
+
+test('the grader health check (grade-sweep Part A) covers the four health axes on live data', (t) => {
   if (!skillsDirExists) return t.skip('.claude/skills not materialized in this checkout');
-  assert.ok(existsSync(SKILL), '.claude/skills/grader-health/SKILL.md must exist (task 1002656)');
-  const md = readFileSync(SKILL, 'utf8');
+  assert.ok(existsSync(SKILL), '.claude/skills/grade-sweep/SKILL.md must exist (task 1004471, was grader-health — task 1002656)');
+  const whole = readFileSync(SKILL, 'utf8');
+  const md = partA(whole);
+  assert.ok(md.length > 1000, 'Part A is present');
 
   // Live data surfaces, named concretely.
   assert.match(md, /\/api\/bongos\/public\/grades/, 'reads the public grade trend');
@@ -44,5 +52,15 @@ test('/grader-health exists and covers the four health axes on live data', (t) =
   assert.match(md, /--probe/, 'offers the optional live calibration probe');
   assert.match(md, /grade-smoke\.js/, 'names the probe script');
   assert.match(md, /read-only/i, 'states the read-only contract');
-  assert.match(md, /ADR 0162/, 'anchors the no-approval-step-on-a-ship constraint');
+  assert.match(whole, /ADR 0162/, 'anchors the no-approval-step-on-a-ship constraint');
+});
+
+test('/grader-health still works when typed: a hidden alias that runs grade-sweep Part A (task 1004471)', (t) => {
+  if (!skillsDirExists) return t.skip('.claude/skills not materialized in this checkout');
+  const md = readFileSync(ALIAS, 'utf8');
+  assert.match(md, /^name: grader-health$/m);
+  assert.match(md, /^disable-model-invocation: true$/m, 'hidden from the model\'s listing, typeable as /grader-health');
+  assert.match(md, /grade-sweep\/SKILL\.md/, 'points at the merged skill by path');
+  assert.match(md, /Part A/, 'runs the health half only');
+  assert.match(md, /--probe/, 'passes --probe through');
 });

package/tests/skill_lint.mjs

@@ -138,6 +138,43 @@ test('the listing counts only RESIDENT skills: an off module\'s skill is linted
   fs.rmSync(root, { recursive: true, force: true });
 });
 
+test('a HIDDEN skill (disable-model-invocation: true) is linted but not counted toward the listing budget, and is reported on its own (task 1004471)', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-lint-hidden-'));
+  const put = (rel, text) => { const p = path.join(root, rel); fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, text); };
+  const skill = (n, extra = '') => `---\nname: ${n}\ndescription: >-\n  ${'y'.repeat(100)}\n${extra}---\nbody\n`;
+  put('.claude/skills/shown/SKILL.md', skill('shown'));
+  put('.claude/skills/tucked/SKILL.md', skill('tucked', 'disable-model-invocation: true\n'));
+  put('.claude/skills/false-flag/SKILL.md', skill('false-flag', 'disable-model-invocation: false\n'));
+  const files = lint.listSkillFiles(root);
+  const report = lint.lintSkills(files, { resident: lint.residentSkillFiles(root, { files }) });
+  assert.equal(report.results.length, 3, 'all three are linted');
+  assert.equal(report.listedSkills, 2, 'only a literal true hides — false stays listed');
+  assert.equal(report.listingChars, ('shown'.length + 100) + ('false-flag'.length + 100));
+  assert.equal(report.hiddenSkills, 1);
+  assert.equal(report.hiddenChars, 'tucked'.length + 100);
+  assert.deepEqual(report.hiddenNames, ['tucked']);
+  const out = lint.format(report, { relTo: root });
+  assert.match(out, /listing 215 chars over 2 listed skill/);
+  assert.match(out, /1 hidden skill\(s\).*not counted\): 106 chars — tucked/);
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('a hidden skill is exempt from the long-description warning (it costs no listing) but not from the hard cap', () => {
+  const long = 'z'.repeat(lint.DESC_WARN_CHARS + 10);
+  assert.equal(run(fm(long, 'disable-model-invocation: true\n')).warnings.length, 0);
+  assert.equal(run(fm(long)).warnings.length, 1, 'the same text listed still warns');
+  assert.equal(run(fm('z'.repeat(lint.DESC_HARD_CHARS + 1), 'disable-model-invocation: true\n')).errors.length, 1);
+  assert.equal(lint.isHidden({ 'disable-model-invocation': 'TRUE ' }), true);
+  assert.equal(lint.isHidden({ 'disable-model-invocation': 'yes' }), false, 'anything but true leaves it listed');
+});
+
+test('the real default listing is under the ~8,000-char budget once hidden skills drop out (task 1004471)', () => {
+  const files = lint.listSkillFiles(ROOT);
+  const report = lint.lintSkills(files, { resident: lint.residentSkillFiles(ROOT, { files }) });
+  assert.equal(report.overBudget, false, `listing is ${report.listingChars} chars over ${report.listedSkills} listed skills`);
+  assert.ok(report.hiddenSkills >= 12, `the owner's hide list is in effect (${report.hiddenSkills} hidden)`);
+});
+
 test('every committed skill parses (the ten that did not on 2026-09-03 must stay fixed)', () => {
   const report = lint.lintSkills(lint.listSkillFiles(ROOT));
   const broken = report.results.filter((r) => r.errors.length).map((r) => path.relative(ROOT, r.file) + ': ' + r.errors.join('; '));

package/tests/skill_menu_ruling.mjs

@@ -0,0 +1,99 @@
+// tests/skill_menu_ruling.mjs — the owner's skill-menu ruling (task 1004471, blocker
+// 1000139) holds: which skills the model is shown, which are hidden but still typeable
+// as /name, and the three merges (/owner-review, /goal-close, /grade-sweep) with every
+// old command still answering. Pinned skill by skill, so a later edit that re-lists a
+// hidden skill, hides a safety net, or breaks an old /name fails here by name.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lint = require('../scripts/gds/skill-lint.js');
+
+const byName = new Map(lint.listSkillFiles(ROOT).map((f) => [path.basename(path.dirname(f)), f]));
+const read = (n) => fs.readFileSync(byName.get(n), 'utf8');
+const info = (n) => lint.lintSkillFile(read(n), { file: byName.get(n) });
+
+// The ruling, as written into the task.
+const LISTED_TRIMMED = ['grade-recover', 'collab-review', 'session-handoff', 'builder-claim', 'builder-sequence', 'blocker-solve', 'design', 'goal-create', 'blocker-review', 'builder-reauth', 'read-session-export', 'recall', 'worktree-clean', 'merge-mode', 'builder-setup', 'builder-key', 'bongos-feedback', 'feedback', 'builder-redteam', 'scan-before-install', 'owner-review'];
+const LISTED_AS_IS = ['strand-fix', 'builder-ship', 'builder-start', 'fix-task', 'ask-for-help', 'ship-check', 'status', 'builder-end', 'builder-release', 'builder-stage'];
+const HIDDEN = ['planning-session', 'goal-close', 'grade-sweep', 'builder-exit', 'builder-backup', 'builder-cost', 'new-project', 'design-sync', 'figma-design-sync', 'tweak'];
+const ALIASES = ['backlog-review', 'bug-triage', 'idea-triage', 'priority-session', 'goal-uat', 'goal-review', 'grade-audit', 'grader-health'];
+
+test('every skill the ruling keeps listed is present, listed, and (where trimmed) at most 250 chars', () => {
+  for (const n of [...LISTED_TRIMMED, ...LISTED_AS_IS]) {
+    assert.ok(byName.has(n), `${n} exists`);
+    const r = info(n);
+    assert.equal(r.hidden, false, `${n} must stay in the model's listing`);
+    assert.deepEqual(r.errors, [], `${n} parses`);
+  }
+  const over = LISTED_TRIMMED.filter((n) => info(n).description.length > 250).map((n) => `${n} ${info(n).description.length}`);
+  assert.deepEqual(over, [], 'trimmed descriptions are <= 250 chars');
+});
+
+test('every skill the ruling hides — and every old name a merge replaced — is hidden but still a typeable skill', () => {
+  for (const n of [...HIDDEN, ...ALIASES]) {
+    assert.ok(byName.has(n), `/${n} still exists, so typing it still works`);
+    assert.equal(info(n).hidden, true, `${n} carries disable-model-invocation: true`);
+  }
+});
+
+test('the safety nets and owner-pinned triggers survive the trim', () => {
+  const d = (n) => info(n).description;
+  assert.match(d('builder-redteam'), /"I found a security issue"/);
+  assert.match(d('scan-before-install'), /"is this plugin safe to install"/);
+  assert.match(d('builder-reauth'), /"Bongos CLI session is no longer valid"/, 'fires on the CLI\'s own error string');
+  assert.match(d('builder-setup'), /"no Bongos session"/, 'fires on the CLI\'s own error string');
+  assert.match(d('builder-key'), /never accept a key pasted in chat/, 'keeps the hard rule in the listing');
+  assert.match(d('bongos-feedback'), /unasked/, 'keeps its unprompted trigger');
+  for (const n of [...LISTED_TRIMMED, ...LISTED_AS_IS, ...HIDDEN, ...ALIASES]) {
+    const fm = read(n).split('\n---')[0];
+    for (const k of ['plain', 'reach-for', 'cost']) assert.match(fm, new RegExp(`^${k}:`, 'm'), `${n} keeps its ${k}: line (the hall Commands page reads it)`);
+  }
+});
+
+test('/owner-review is the listed front door to backlog -> bugs -> ideas -> priorities, and plain words open each step', () => {
+  const md = read('owner-review');
+  const desc = info('owner-review').description;
+  for (const phrase of ['"review the backlog"', '"triage bugs"', '"triage ideas"', '"review the inbox"']) assert.ok(desc.includes(phrase), `listing routes ${phrase}`);
+  const order = ['backlog-review', 'bug-triage', 'idea-triage', 'priority-session'].map((s) => md.indexOf(`.claude/skills/${s}/SKILL.md`));
+  assert.ok(order.every((i) => i > 0), 'each step names its playbook by path');
+  assert.deepEqual([...order].sort((a, b) => a - b), order, 'in the ruling\'s order');
+  for (const step of ['backlog', 'bugs', 'ideas', 'priorities']) assert.match(md, new RegExp('`' + step + '`'), `/owner-review ${step} opens one step`);
+  assert.match(md, /Read that step's `SKILL\.md` with the Read tool/, 'the model reads a hidden step by path — the Skill tool cannot load it');
+  for (const s of ['backlog-review', 'bug-triage', 'idea-triage', 'priority-session']) assert.match(md, new RegExp('`/' + s + '`'), `/${s} is named as still typeable`);
+});
+
+test('the nightly idea-triage routine still finds the playbook it reads by path', () => {
+  const nightly = fs.readFileSync(path.join(ROOT, '.claude/scheduled-tasks/idea-triage-nightly/SKILL.md'), 'utf8');
+  assert.match(nightly, /\.claude\/skills\/idea-triage\/SKILL\.md/);
+  assert.ok(fs.existsSync(path.join(ROOT, '.claude/skills/idea-triage/SKILL.md')));
+  assert.ok(read('idea-triage').length > 5000, 'the full playbook, not an alias stub');
+});
+
+test('/goal-close carries both halves; /goal-uat and /goal-review run one each', () => {
+  const md = read('goal-close');
+  const p1 = md.indexOf('## Part 1'), p2 = md.indexOf('## Part 2');
+  assert.ok(p1 > 0 && p2 > p1, 'UAT part, then residue part');
+  assert.match(md.slice(p1, p2), /uat\.js --queue/, 'Part 1 reads the UAT queue');
+  assert.match(md.slice(p1, p2), /--recording/, 'Part 1 signs off with a recording');
+  assert.match(md.slice(p2), /done-when\/pending-review/, 'Part 2 reads the review queue');
+  assert.match(md.slice(p2), /override_reason/, 'Part 2 overrides only with a written reason');
+  assert.match(md, /xenos/, 'one Metic+ gate at the top');
+  assert.match(read('goal-uat'), /goal-close\/SKILL\.md[\s\S]*Part 1/);
+  assert.match(read('goal-review'), /goal-close\/SKILL\.md[\s\S]*Part 2/);
+});
+
+test('/tweak lives in the copy-desk module, which contributes it (default-on, so it stays installed)', () => {
+  assert.ok(fs.existsSync(path.join(ROOT, 'modules/copy-desk/skills/tweak/SKILL.md')));
+  assert.ok(!fs.existsSync(path.join(ROOT, '.claude/skills/tweak/SKILL.md')) || !require('node:child_process').execFileSync('git', ['ls-files', '.claude/skills/tweak'], { cwd: ROOT, encoding: 'utf8' }).trim(), 'no tracked core copy (an untracked materialised one is fine)');
+  const mj = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules/copy-desk/module.json'), 'utf8'));
+  assert.deepEqual(mj.contributes.skills, ['tweak']);
+  assert.equal(mj.default, true);
+  const files = lint.listSkillFiles(ROOT);
+  assert.ok(lint.residentSkillFiles(ROOT, { files }).some((f) => path.basename(path.dirname(f)) === 'tweak'), 'resident on a default instance');
+});