@bongos/core 1.20.41 → 1.20.43

package/tests/module_assess_security.mjs

@@ -0,0 +1,216 @@
+// tests/module_assess_security.mjs — the Security assessment gate (task 1003792, ADR 0343 D2).
+// No database and no network: the dependency audit is injected (and auditDependencies
+// is driven with a fake npm), the store row goes to a fake pg client, and the tarball
+// is a REAL packed + verified one. Pinned:
+//   - the outcome is only ever passed / failed / not_scored — never a number (D2 gate)
+//   - denied files, a non-registry dependency source and a high/critical advisory fail
+//   - an audit that cannot run is not_scored, never a pass (a gate that cannot run stays shut)
+//   - floating ranges and the maintenance posture are reported, never failed on
+//
+// Run:  node tests/module_assess_security.mjs
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { assessSecurity, auditDependencies, recordSecuritySignal, insertSecuritySignal, maintenancePosture, registrySpec } = require('../scripts/gds/module-assess-security.js');
+const { packModule } = require('../scripts/gds/module-artifact.js');
+const { relativeArtifactPath } = require('../src/bongos/module-store.js');
+
+const file = (p, text = '') => ({ path: p, buf: Buffer.from(text) });
+const MJ = (over = {}) => ({ key: 'weather', title: 'Weather', description: 'x', version: '1.2.0', coreVersion: '^1.0.0', contributes: {}, ...over });
+const clean = async () => ({ ok: true, findings: [] });
+const noAudit = async () => { throw new Error('the audit must not run for a module with no dependencies'); };
+
+test('no dependencies and no denied files passes, with no number and no audit', async () => {
+  const s = await assessSecurity('weather', [file('module.json'), file('index.js')], MJ(), { audit: noAudit });
+  assert.equal(s.outcome, 'passed');
+  assert.equal(s.score, null, 'the gate never carries a score (core_265: security is pass/fail only)');
+  assert.equal(s.sample_size, 0);
+});
+
+test('a credential-named file fails the gate on the publish denylist', async () => {
+  const s = await assessSecurity('weather', [file('module.json'), file('.env', 'X=1')], MJ(), { audit: noAudit });
+  assert.equal(s.outcome, 'failed');
+  assert.deepEqual(s.detail.failures.map((f) => f.check), ['denylist']);
+  assert.deepEqual(s.detail.failures[0].files, ['modules/weather/.env']);
+});
+
+test('a dependency fetched from outside the registry fails, and is never handed to npm', async () => {
+  const specs = ['git+https://example.invalid/x.git', 'https://example.invalid/x.tgz', 'github:someone/thing', 'someone/thing',
+    'npm:other@1.0.0', 'file:../../../../etc', 'link:../x', 'workspace:*', '1.0.0 || file:../x', 'git@github.com:a/b', 'rm -rf /', 'a#b'];
+  for (const spec of specs) {
+    const s = await assessSecurity('weather', [file('module.json')],
+      MJ({ dependencies: { lodash: '^4.17.21', thing: spec } }), { audit: noAudit });
+    assert.equal(s.outcome, 'failed', spec);
+    assert.equal(s.detail.failures[0].check, 'dependency_source', spec);
+    assert.deepEqual(s.detail.failures[0].dependencies.map((d) => d.package), ['thing'], spec);
+  }
+  const badName = await assessSecurity('weather', [file('module.json')], MJ({ dependencies: { '../evil': '1.0.0' } }), { audit: noAudit });
+  assert.equal(badName.outcome, 'failed');
+});
+
+test('registry specs: pinned, ranges and wildcards are allowed and told apart', () => {
+  const cases = [['1.2.3', 'pinned'], ['1.2.3-beta.1', 'pinned'], ['^14.26.4', 'floating range'], ['~1.2', 'floating range'],
+    ['>=1.0.0 <2.0.0', 'floating range'], ['1.x', 'floating range'], ['1.0.0 - 2.0.0', 'floating range'], ['^1 || ^2', 'floating range'],
+    ['*', 'wildcard'], ['latest', 'wildcard'], ['', 'wildcard']];
+  for (const [spec, kind] of cases) assert.deepEqual(registrySpec('lodash', spec), { ok: true, kind }, spec);
+  assert.equal(registrySpec('@scope/pkg', '^1.0.0').ok, true);
+});
+
+test('a wildcard is noted separately from a floating range', async () => {
+  const s = await assessSecurity('weather', [file('module.json')], MJ({ dependencies: { a: '*', b: '^1.0.0', c: '1.0.0' } }), { audit: clean });
+  assert.equal(s.outcome, 'passed');
+  assert.deepEqual(s.detail.notes.filter((n) => n.check.startsWith('dependency')).map((n) => [n.check, n.package]),
+    [['dependency_wildcard', 'a'], ['dependency_range', 'b']]);
+});
+
+test('a floating range is only noted', async () => {
+  const ok = await assessSecurity('weather', [file('module.json')], MJ({ dependencies: { lodash: '^4.17.21' } }), { audit: clean });
+  assert.equal(ok.outcome, 'passed');
+  assert.equal(ok.sample_size, 1);
+  assert.equal(ok.detail.notes.find((n) => n.check === 'dependency_range').package, 'lodash');
+});
+
+test('a high or critical advisory in a dependency fails the gate and names it', async () => {
+  const audit = async (deps) => {
+    assert.deepEqual(deps, { lodash: '^4.0.0' }, 'the audit sees exactly the declared dependencies');
+    return { ok: true, findings: [{ package: 'lodash', severity: 'critical', id: 'GHSA-x', summary: 'Prototype pollution', fix: 'lodash@4.17.21' }] };
+  };
+  const s = await assessSecurity('weather', [file('module.json')], MJ({ dependencies: { lodash: '^4.0.0' } }), { audit });
+  assert.equal(s.outcome, 'failed');
+  const v = s.detail.failures.find((f) => f.check === 'vulnerable_dependency');
+  assert.equal(v.advisories[0].id, 'GHSA-x');
+});
+
+test('an audit that cannot run is not_scored — never a pass', async () => {
+  const s = await assessSecurity('weather', [file('module.json')], MJ({ dependencies: { lodash: '^4.0.0' } }),
+    { audit: async () => ({ ok: false, reason: 'offline' }) });
+  assert.equal(s.outcome, 'not_scored');
+  assert.match(s.reason, /could not run/);
+});
+
+test('the maintenance posture is reported, never failed on', async () => {
+  assert.equal(maintenancePosture(MJ()), 'undeclared');
+  assert.equal(maintenancePosture(MJ({ maintenance: { status: 'orphaned' } })), 'orphaned');
+  for (const status of [undefined, 'deprecated', 'orphaned']) {
+    const mj = status ? MJ({ maintenance: { status, note: 'n' } }) : MJ();
+    const s = await assessSecurity('weather', [file('module.json')], mj, { audit: noAudit });
+    assert.equal(s.outcome, 'passed', String(status));
+    assert.equal(s.detail.notes.find((n) => n.check === 'maintenance').status, status || 'undeclared');
+  }
+  const kept = await assessSecurity('weather', [file('module.json')], MJ({ maintainer: 'a', maintenance: { status: 'maintained' } }), { audit: noAudit });
+  assert.equal(kept.detail.notes.length, 0, 'a maintained module has nothing to note');
+});
+
+// ---- auditDependencies: npm driven through a fake exec ----
+
+function fakeNpm({ lockOk = true, auditOut }) {
+  const calls = [];
+  const exec = (cmd, argv, opts, cb) => {
+    const args = cmd === 'cmd.exe' ? argv.slice(argv.indexOf('npm') + 1) : argv;
+    calls.push({ args, pkg: JSON.parse(fs.readFileSync(path.join(opts.cwd, 'package.json'), 'utf8')) });
+    if (args[0] === 'install') {
+      if (lockOk) fs.writeFileSync(path.join(opts.cwd, 'package-lock.json'), '{}');
+      return cb(lockOk ? null : new Error('E404'), '', '');
+    }
+    return cb(new Error('exit 1'), auditOut, '');
+  };
+  return { calls, exec };
+}
+
+test('the audit resolves metadata only (no install scripts) and reads npm audit\'s JSON', async () => {
+  const auditOut = JSON.stringify({ vulnerabilities: { lodash: { severity: 'high', via: [{ source: 1, title: 'Bad', severity: 'high', url: 'u' }], fixAvailable: true }, tiny: { severity: 'low', via: [] } } });
+  const npm = fakeNpm({ auditOut });
+  const a = await auditDependencies({ lodash: '^4.0.0' }, { exec: npm.exec });
+  assert.equal(a.ok, true);
+  assert.deepEqual(a.findings.map((f) => f.package), ['lodash'], 'only high and critical count');
+  const install = npm.calls[0].args;
+  assert.equal(install[0], 'install');
+  assert.ok(install.includes('--package-lock-only') && install.includes('--ignore-scripts'), 'no package code is downloaded or run');
+  assert.deepEqual(npm.calls[0].pkg.dependencies, { lodash: '^4.0.0' });
+});
+
+test('an unresolvable dependency or an unreadable audit is a failed audit run, not a clean one', async () => {
+  assert.equal((await auditDependencies({ nope: '^1.0.0' }, { exec: fakeNpm({ lockOk: false }).exec })).ok, false);
+  assert.equal((await auditDependencies({ a: '^1.0.0' }, { exec: fakeNpm({ auditOut: 'not json' }).exec })).ok, false);
+  assert.equal((await auditDependencies({ a: '^1.0.0' }, { exec: fakeNpm({ auditOut: JSON.stringify({ error: { code: 'ENOAUDIT' } }) }).exec })).ok, false);
+});
+
+// ---- recordSecuritySignal: tarball in, one appended row out ----
+
+function fakeDb(versionRow) {
+  const inserts = [];
+  return {
+    inserts,
+    async query(sql, params) {
+      if (/FROM store_module_versions/.test(sql)) return { rows: versionRow ? [versionRow] : [] };
+      if (/INSERT INTO module_assessment_signals/.test(sql)) {
+        assert.match(sql, /'security'/);
+        assert.doesNotMatch(sql, /UPDATE/i);
+        inserts.push(params);
+        return { rows: [{ id: 3, version_id: params[0], part: 'security', outcome: params[1] }] };
+      }
+      throw new Error(`unexpected query: ${sql}`);
+    },
+  };
+}
+
+function published(mj = MJ()) {
+  const src = fs.mkdtempSync(path.join(os.tmpdir(), 'mod-sec-src-'));
+  fs.mkdirSync(path.join(src, 'weather'), { recursive: true });
+  fs.writeFileSync(path.join(src, 'weather', 'module.json'), JSON.stringify(mj));
+  fs.writeFileSync(path.join(src, 'weather', 'index.js'), 'module.exports = {};\n');
+  const { tgz } = packModule('weather', { modulesDir: src, now: () => new Date('2026-09-30T00:00:00Z'), modeOf: () => '644' });
+  const storeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mod-sec-store-'));
+  const final = path.join(storeDir, 'weather', 'weather-1.2.0.tgz');
+  fs.mkdirSync(path.dirname(final), { recursive: true });
+  fs.writeFileSync(final, tgz);
+  return { storeDir, final, row: { id: 42, module_key: 'weather', version: '1.2.0', artifact_path: relativeArtifactPath(final, { dir: storeDir }) } };
+}
+
+test('a published version is checked from its tarball and one security row is appended', async () => {
+  const { storeDir, row } = published(MJ({ dependencies: { lodash: '^4.17.21' } }));
+  const db = fakeDb(row);
+  let audited = null;
+  const res = await recordSecuritySignal(42, { db, storeDir, audit: async (d) => { audited = d; return { ok: true, findings: [] }; } });
+  assert.equal(res.ok, true);
+  assert.deepEqual(audited, { lodash: '^4.17.21' }, 'the dependencies come from the published module.json');
+  const [versionId, outcome, score, sample] = db.inserts[0];
+  assert.deepEqual([versionId, outcome, score, sample], [42, 'passed', null, 1]);
+});
+
+test('a missing or tampered tarball is not_scored, and an unknown version writes nothing', async () => {
+  const { storeDir, final, row } = published();
+  fs.writeFileSync(final, 'junk');
+  const db = fakeDb(row);
+  await recordSecuritySignal(42, { db, storeDir, audit: noAudit });
+  assert.equal(db.inserts[0][1], 'not_scored');
+  assert.doesNotMatch(db.inserts[0][4], /[\\/]/, 'no local path in the stored reason');
+
+  const none = fakeDb(null);
+  const res = await recordSecuritySignal(9, { db: none, audit: noAudit });
+  assert.equal(res.code, 'version_not_found');
+  assert.equal(none.inserts.length, 0);
+});
+
+test('insertSecuritySignal writes the security part with no score', async () => {
+  const seen = [];
+  await insertSecuritySignal(5, { outcome: 'failed', score: null, sample_size: 2, reason: 'r', detail: { failures: [] } },
+    { db: { async query(sql, params) { seen.push(params); return { rows: [{}] }; } } });
+  assert.deepEqual(seen[0], [5, 'failed', null, 2, 'r', '{"failures":[]}']);
+});
+
+test('a core script never requires a module file (the one-way rule)', () => {
+  const src = fs.readFileSync(new URL('../scripts/gds/module-assess-security.js', import.meta.url), 'utf8').replace(/\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /require\([^)]*modules\//);
+});
+
+test('the gate never runs the module\'s own code', () => {
+  const src = fs.readFileSync(new URL('../scripts/gds/module-assess-security.js', import.meta.url), 'utf8').replace(/\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /process\.execPath|require\(\s*path\.join|import\(/, 'no node process or require over module files');
+});

package/tests/skill_grade_audit.mjs

@@ -1,9 +1,10 @@
-// tests/skill_grade_audit.mjs — the /grade-audit skill exists and covers the
-// accountability sweep from the grader-hardening evaluation §6 (task 1002657):
-// the override ledger, dropped blocker/major findings on passing grades (with
-// the advisory-Narc attribution filter), the false-pass spot-check, and the
-// outage roll-up handoff — describing and queueing ONLY (ADR 0158 §2: it
-// never confirms a task or flips status; ADR 0162: it adds no approval step to a ship).
+// tests/skill_grade_audit.mjs — the grade AUDIT (once /grade-audit, now Part B of the
+// merged /grade-sweep — task 1004471) covers the accountability sweep from the
+// grader-hardening evaluation §6 (task 1002657): the override ledger, dropped
+// blocker/major findings on passing grades (with the advisory-Narc attribution
+// filter), the false-pass spot-check, and the outage roll-up handoff — describing and
+// queueing ONLY (ADR 0158 §2: it never confirms a task or flips status; ADR 0162: it
+// adds no approval step to a ship). /grade-audit stays typeable as a hidden alias.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { readFileSync, existsSync } from 'node:fs';
@@ -11,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', 'grade-audit', 'SKILL.md');
+const SKILL = path.join(ROOT, '.claude', 'skills', 'grade-sweep', 'SKILL.md');
+const ALIAS = path.join(ROOT, '.claude', 'skills', 'grade-audit', '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('/grade-audit exists, covers the sweep legs, and stays describe-and-queue only', (t) => {
+// Part B of the merged file: from its heading to the shared report section.
+const partB = (md) => md.slice(md.indexOf('## Part B'), md.indexOf('## Report shape'));
+
+test('the grade audit (grade-sweep Part B) covers the sweep legs, and stays describe-and-queue only', (t) => {
   if (!skillsDirExists) return t.skip('.claude/skills not materialized in this checkout');
-  assert.ok(existsSync(SKILL), '.claude/skills/grade-audit/SKILL.md must exist (task 1002657)');
-  const md = readFileSync(SKILL, 'utf8');
+  assert.ok(existsSync(SKILL), '.claude/skills/grade-sweep/SKILL.md must exist (task 1004471, was grade-audit — task 1002657)');
+  const whole = readFileSync(SKILL, 'utf8');
+  const md = partB(whole);
+  assert.ok(md.length > 1000, 'Part B is present');
 
   // Data surfaces.
   assert.match(md, /\/api\/bongos\/public\/recent-shipped/, 'sweeps the recent-shipped window');
@@ -35,16 +42,26 @@ test('/grade-audit exists, covers the sweep legs, and stays describe-and-queue o
   assert.match(md, /blocker|major/, 'targets blocker/major findings on passing grades');
   assert.match(md, /Narc/i, 'carries the advisory-Narc attribution filter');
   assert.match(md, /capture\.js/, 'queues findings via capture.js');
-  assert.match(md, /\[grade-audit\]/, 'uses the deterministic title marker for idempotency');
+  assert.match(md, /\[grade-audit\]/, 'keeps the deterministic title marker for idempotency (old rows carry it)');
 
   // Leg 3 — false-pass spot-check (the 2/8 runtime-blindness classes).
   assert.match(md, /runtime/i, 'spot-checks for runtime-behavior blindness');
 
-  // Leg 4 — outage roll-up handoff.
-  assert.match(md, /\/grader-health/, 'hands outage windows to /grader-health');
+  // Leg 4 — outage roll-up hands a streak to the health half, now in the same file.
+  assert.match(md, /Part A/, 'hands outage streaks to Part A (was /grader-health)');
+
+  // The hard constraint — stated once for the whole merged skill.
+  assert.match(whole, /never confirm/i, 'states it never confirms');
+  assert.match(whole, /ADR 0162/, 'anchors the no-approval-step-on-a-ship constraint');
+  assert.ok(!/curl[^\n]*\/confirm/.test(whole), 'carries no ready-to-paste confirm curl');
+});
 
-  // The hard constraint.
-  assert.match(md, /never confirm/i, 'states it never confirms');
-  assert.match(md, /ADR 0162/, 'anchors the no-approval-step-on-a-ship constraint');
-  assert.ok(!/curl[^\n]*\/confirm/.test(md), 'carries no ready-to-paste confirm curl');
+test('/grade-audit still works when typed: a hidden alias that runs grade-sweep Part B (task 1004471)', (t) => {
+  if (!skillsDirExists) return t.skip('.claude/skills not materialized in this checkout');
+  const md = readFileSync(ALIAS, 'utf8');
+  assert.match(md, /^name: grade-audit$/m);
+  assert.match(md, /^disable-model-invocation: true$/m, 'hidden from the model\'s listing, typeable as /grade-audit');
+  assert.match(md, /grade-sweep\/SKILL\.md/, 'points at the merged skill by path');
+  assert.match(md, /Part B/, 'runs the audit half only');
+  assert.match(readFileSync(SKILL, 'utf8'), /^disable-model-invocation: true$/m, 'the merged grade skill is hidden too (owner ruling)');
 });

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');
+});