@bongos/core 1.21.176 → 1.21.178

package/tests/gate_review.mjs

@@ -1,152 +0,0 @@
-// tests/gate_review.mjs
-//
-// Unit tests for the automatic gate-surface gatekeeper classifier (ADR 0058,
-// task 1139). classifyChanges is PURE (diff-as-data in, verdict out) so the whole
-// policy — including every red-team evasion the design workflow surfaced — is a
-// regression case here. DB-free / network-free → runs in the unit gate.
-//
-// Verdicts: pass (auto-merge) | needs_trust (Metic+ auto / else escalate) | escalate
-// (hard floor — rank-independent, always pings the owner).
-//
-// Run:  node tests/gate_review.mjs
-
-import { strict as assert } from 'node:assert';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const gk = require('../scripts/bongos/gate-review.js');
-const permPath = require('../src/bongos/permission-path-check.js');
-
-let passed = 0, failed = 0;
-function test(name, fn) {
-  try { fn(); passed++; console.log(`  ok  ${name}`); }
-  catch (e) { failed++; console.log(`  FAIL ${name}\n     ${e.message}`); }
-}
-
-// Build a classifyChanges call from a compact spec.
-//   files: [{path, mode?, deleted?}]   blobs: { 'base:path':..., 'head:path':... }
-function classify(files, blobs = {}, diffBytes = 0) {
-  const blobAt = (which, p) => (Object.prototype.hasOwnProperty.call(blobs, `${which}:${p}`) ? blobs[`${which}:${p}`] : null);
-  return gk.classifyChanges({ files: files.map((f) => ({ mode: '100644', deleted: false, ...f })), blobAt, diffBytes });
-}
-const verdictOf = (...a) => classify(...a).verdict;
-
-// --- PASS: no gate surface / pure-narrowing AUTO -------------------------------------
-test('no gate surface (game/art/docs) → pass', () => {
-  assert.equal(verdictOf([{ path: 'public/game/main.js' }, { path: 'docs/foo.md' }, { path: 'art/x.png' }]), 'pass');
-});
-test('adding a new test file → pass', () => {
-  assert.equal(verdictOf([{ path: 'tests/new_thing.mjs' }], { 'head:tests/new_thing.mjs': 'test(...)' }), 'pass');
-});
-test('run-unit-tests.js REMOVING from INTEGRATION (un-mute) → pass (AUTO)', () => {
-  const base = `const INTEGRATION = new Set(['a','b']);\nconst KNOWN_FAILING = new Set(['x']);\nconst Z=1;`;
-  const head = `const INTEGRATION = new Set(['a']);\nconst KNOWN_FAILING = new Set(['x']);\nconst Z=1;`;
-  const r = classify([{ path: 'scripts/bongos/run-unit-tests.js' }], { 'base:scripts/bongos/run-unit-tests.js': base, 'head:scripts/bongos/run-unit-tests.js': head });
-  assert.equal(r.verdict, 'pass');
-  assert.deepEqual(r.autoPassed, ['scripts/bongos/run-unit-tests.js']);
-});
-test('secrets-allowlist.txt REMOVING a line (narrow) → pass (AUTO)', () => {
-  const r = classify([{ path: '.husky/secrets-allowlist.txt' }], { 'base:.husky/secrets-allowlist.txt': 'aaa\nbbb\n', 'head:.husky/secrets-allowlist.txt': 'aaa\n' });
-  assert.equal(r.verdict, 'pass');
-});
-
-// --- NEEDS_TRUST: sensitive-but-routine (rank-trustable) -----------------------------
-test('new migration → needs_trust', () => assert.equal(verdictOf([{ path: 'migrations/120_thing.sql' }]), 'needs_trust'));
-test('package.json bump → needs_trust', () => assert.equal(verdictOf([{ path: 'package.json' }]), 'needs_trust'));
-test('a route file → needs_trust', () => assert.equal(verdictOf([{ path: 'src/bongos/routes/tasks.js' }]), 'needs_trust'));
-test('server.js → needs_trust', () => assert.equal(verdictOf([{ path: 'server.js' }]), 'needs_trust'));
-test('ship.js → needs_trust', () => assert.equal(verdictOf([{ path: 'scripts/bongos/ship.js' }]), 'needs_trust'));
-test('db.js change OUTSIDE the rank-tier region → needs_trust', () => {
-  const base = `const REQUIRES_RANK_TIER = { foo: 1 };\nfunction q(){ return 1 }`;
-  const head = `const REQUIRES_RANK_TIER = { foo: 1 };\nfunction q(){ return 2 }`;
-  assert.equal(verdictOf([{ path: 'src/bongos/db.js' }], { 'base:src/bongos/db.js': base, 'head:src/bongos/db.js': head }), 'needs_trust');
-});
-test('deleting a test file → needs_trust', () => assert.equal(verdictOf([{ path: 'tests/route_rank.mjs', deleted: true }]), 'needs_trust'));
-test('shrinking a test file → needs_trust', () => {
-  assert.equal(verdictOf([{ path: 'tests/route_rank.mjs' }], { 'base:tests/route_rank.mjs': 'x'.repeat(500), 'head:tests/route_rank.mjs': 'x'.repeat(50) }), 'needs_trust');
-});
-
-// --- ESCALATE: HARD FLOOR (rank-independent) -----------------------------------------
-for (const p of [
-  'scripts/bongos/gate-review.js', 'src/bongos/permission-path-check.js', 'src/bongos/auth.js',
-  'src/bongos/route-rank-check.js', 'modules/grading/grader.js', 'modules/grading/grader-workers/narc.js',
-  'scripts/bongos/main-audit.js', 'scripts/migrate.sh', 'scripts/deploy/deploy-prod.sh',
-  'config/deploy.json', 'infra/branch-protection.json', '.github/workflows/gate-review.yml',
-  'CODEOWNERS', '.husky/pre-push', '.claude/hooks/stop-sound.js', '.claude/settings.json',
-]) {
-  test(`hard floor: ${p} → escalate`, () => assert.equal(verdictOf([{ path: p }]), 'escalate'));
-}
-test('db.js with the rank-tier region CHANGED → escalate', () => {
-  const base = `const REQUIRES_RANK_TIER = { foo: 1 };\nfunction q(){}`;
-  const head = `const REQUIRES_RANK_TIER = { foo: 4, bar: 1 };\nfunction q(){}`;
-  assert.equal(verdictOf([{ path: 'src/bongos/db.js' }], { 'base:src/bongos/db.js': base, 'head:src/bongos/db.js': head }), 'escalate');
-});
-
-// --- ESCALATE: red-team evasions -----------------------------------------------------
-test('Hole(mute): run-unit-tests.js ADDING to KNOWN_FAILING → escalate (AUTO cert fails → floor)', () => {
-  const base = `const INTEGRATION = new Set(['a']);\nconst KNOWN_FAILING = new Set(['x']);`;
-  const head = `const INTEGRATION = new Set(['a']);\nconst KNOWN_FAILING = new Set(['x','grader_panel']);`;
-  assert.equal(verdictOf([{ path: 'scripts/bongos/run-unit-tests.js' }], { 'base:scripts/bongos/run-unit-tests.js': base, 'head:scripts/bongos/run-unit-tests.js': head }), 'escalate');
-});
-test('Hole(mute): run-unit-tests.js non-set code changed → escalate', () => {
-  const base = `const INTEGRATION = new Set(['a']);\nconst KNOWN_FAILING = new Set([]);\nconst TIMEOUT=90000;`;
-  const head = `const INTEGRATION = new Set(['a']);\nconst KNOWN_FAILING = new Set([]);\nconst TIMEOUT=1;`;
-  assert.equal(verdictOf([{ path: 'scripts/bongos/run-unit-tests.js' }], { 'base:scripts/bongos/run-unit-tests.js': base, 'head:scripts/bongos/run-unit-tests.js': head }), 'escalate');
-});
-test('Hole(allowlist): secrets-allowlist.txt ADDING a broadening line → escalate', () => {
-  assert.equal(verdictOf([{ path: '.husky/secrets-allowlist.txt' }], { 'base:.husky/secrets-allowlist.txt': 'aaa\n', 'head:.husky/secrets-allowlist.txt': 'aaa\nLEAKED_KEY=.*\n' }), 'escalate');
-});
-test('Hole8: a symlink in the diff → escalate (alias evasion)', () => {
-  assert.equal(verdictOf([{ path: 'src/bongos/routes/x.js', mode: '120000' }]), 'escalate');
-});
-test('Hole6/8: a non-ASCII/homoglyph path → escalate', () => {
-  assert.equal(verdictOf([{ path: 'src/bongos/аuth.js' /* cyrillic a */ }]), 'escalate');
-});
-test('Hole10: oversize diff → escalate', () => {
-  assert.equal(verdictOf([{ path: 'public/game/main.js' }], {}, 9 * 1024 * 1024), 'escalate');
-});
-test('Hole2: editing gate-review.yml (self-neuter) → escalate', () => {
-  assert.equal(verdictOf([{ path: '.github/workflows/gate-review.yml' }]), 'escalate');
-});
-test('Hole4: adding a new middleware + editing routes.js → escalate (auth.js floor) / needs_trust (routes)', () => {
-  // routes.js is needs_trust; but pairing with a hard-floor file makes the PR escalate.
-  assert.equal(verdictOf([{ path: 'src/bongos/routes.js' }, { path: 'src/bongos/auth.js' }]), 'escalate');
-});
-
-// --- DRIFT GUARD: no PROTECTED_GLOBS entry is silently un-routed (never pass) ---------
-test('drift guard: every PROTECTED_GLOBS entry routes to escalate or needs_trust (never pass)', () => {
-  for (const glob of permPath.PROTECTED_GLOBS) {
-    // Synthesize a representative path under each glob.
-    const sample = glob.endsWith('/') ? `${glob}__sample__.js` : glob;
-    // db.js needs blobs to classify; give it a no-op (region unchanged) → needs_trust (still not pass).
-    const blobs = sample === 'src/bongos/db.js'
-      ? { 'base:src/bongos/db.js': 'const REQUIRES_RANK_TIER = {};\nx', 'head:src/bongos/db.js': 'const REQUIRES_RANK_TIER = {};\ny' }
-      : {};
-    const v = verdictOf([{ path: sample }], blobs);
-    assert.notEqual(v, 'pass', `PROTECTED glob ${glob} (sample ${sample}) classified as PASS — gate-surface leak`);
-  }
-});
-test('drift guard: every HARD_FLOOR glob is also covered by PROTECTED_GLOBS (sub-Metic floor protects the gate machinery)', () => {
-  for (const g of gk.HARD_FLOOR_GLOBS) {
-    // a floor glob must be matched by SOME protected glob (subtree-aware): a file under it is protected.
-    const sample = g.endsWith('/') ? `${g}__s__` : g;
-    assert.equal(permPath.matchProtected([sample]).length > 0, true, `hard-floor ${g} is not in PROTECTED_GLOBS`);
-  }
-});
-
-// --- resolveAction: rank clears needs_trust; ONLY an owner review clears the hard floor (task 1142) ---
-const RA = (verdict, trusted, ownerApproved) => gk.resolveAction({ verdict, trusted, ownerApproved });
-test('resolveAction: pass → pass regardless of trust', () => {
-  assert.equal(RA('pass', false, false), 'pass');
-});
-test('resolveAction: needs_trust + Metic+ attestation → pass', () => assert.equal(RA('needs_trust', true, false), 'pass'));
-test('resolveAction: needs_trust + untrusted + no approval → block', () => assert.equal(RA('needs_trust', false, false), 'block'));
-test('resolveAction: needs_trust + owner approval (untrusted) → pass', () => assert.equal(RA('needs_trust', false, true), 'pass'));
-test('resolveAction: escalate + trusted but NOT owner-approved → block (rank never clears the hard floor)', () => {
-  assert.equal(RA('escalate', true, false), 'block');
-});
-test('resolveAction: escalate + owner approval → pass (only the owner clears the floor)', () => assert.equal(RA('escalate', false, true), 'pass'));
-test('resolveAction: escalate + nothing → block', () => assert.equal(RA('escalate', false, false), 'block'));
-
-console.log(`\ngate-review (task 1139) tests: ${passed} passed, ${failed} failed`);
-process.exit(failed > 0 ? 1 : 0);

package/tests/goal_names.mjs

@@ -1,120 +0,0 @@
-// tests/goal_names.mjs — the goal rename mapping (task 1003225, goal 1000072,
-// criterion legibility-goal-names-and-claude-text).
-//
-// The mapping IS the decision, so these tests are the review that a shell
-// history could never get: no name may still carry its own explanation, no two
-// goals may end up with the same name, and re-running must be a no-op.
-import { strict as assert } from 'node:assert';
-import { test } from 'node:test';
-import { createRequire } from 'node:module';
-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 { GOAL_NAMES, ALREADY_NAMES, SEPARATOR } = require(path.join(ROOT, 'scripts', 'bongos', 'goal-names.js'));
-const { planFor } = require(path.join(ROOT, 'scripts', 'bongos', 'rename-goals.js'));
-
-const entries = () => Object.entries(GOAL_NAMES).map(([id, v]) => [Number(id), v]);
-
-test('THE POINT: no new title carries its own explanation', () => {
-  // A dash or a colon in the name means the split did not happen.
-  for (const [id, v] of entries()) {
-    assert.ok(!SEPARATOR.test(v.title), `${id} still jams its explanation into the name: ${v.title}`);
-  }
-});
-
-test('no two goals end up with the same name', () => {
-  // The failure a mechanical split would have produced: 1000038/39/40 all head
-  // "Agents module", so splitting on the separator leaves three identical names.
-  const seen = new Map();
-  for (const [id, v] of entries()) {
-    const key = v.title.toLowerCase();
-    assert.ok(!seen.has(key), `${id} and ${seen.get(key)} would both be named "${v.title}"`);
-    seen.set(key, id);
-  }
-});
-
-test('the three Agents goals are genuinely distinguishable', () => {
-  const [a, b, c] = [1000038, 1000039, 1000040].map((id) => GOAL_NAMES[id]);
-  for (const g of [a, b, c]) assert.ok(g, 'all three are mapped');
-  const names = new Set([a.title, b.title, c.title]);
-  assert.equal(names.size, 3, 'three distinct names');
-  // And each says what IT is, not merely that it is an agents goal.
-  for (const g of [a, b, c]) {
-    assert.ok(g.title.length > 'Agents module'.length, `"${g.title}" must add something`);
-  }
-});
-
-test('every goal keeps an explanation — nothing is dropped', () => {
-  for (const [id, v] of entries()) {
-    assert.equal(typeof v.subtitle, 'string', `${id} has a subtitle`);
-    assert.ok(v.subtitle.trim().length >= 20, `${id}'s subtitle must carry the real explanation, not a stub`);
-    assert.notEqual(v.subtitle.trim().toLowerCase(), v.title.trim().toLowerCase(), `${id} must not restate its name`);
-  }
-});
-
-test('a name reads as a name, not a sentence', () => {
-  for (const [id, v] of entries()) {
-    assert.ok(v.title.length <= 40, `${id} "${v.title}" is ${v.title.length} chars — too long to scan in a list`);
-    assert.ok(!v.title.endsWith('.'), `${id} "${v.title}" should not be punctuated like prose`);
-  }
-});
-
-test('every name written with JUDGMENT records why', () => {
-  // Where the new name is not simply the old head, the reason is part of the
-  // artifact — that is what makes this reviewable rather than asserted.
-  for (const id of [1000003, 1000038, 1000039, 1000040, 1000053, 1000064, 1000075, 1000077, 1000078]) {
-    const v = GOAL_NAMES[id];
-    assert.ok(v, `${id} is mapped`);
-    assert.ok(v.why && v.why.length > 25, `${id} must record why its name was rewritten`);
-  }
-});
-
-test('the mapping and the leave-alone list are disjoint', () => {
-  for (const id of ALREADY_NAMES) {
-    assert.ok(!GOAL_NAMES[id], `${id} cannot be both renamed and deliberately untouched`);
-  }
-});
-
-test('mapping + leave-alone accounts for every open goal', () => {
-  // 38 = 32 mapping entries + 6 already-names. This is a fact about THIS FILE, not
-  // about how many goals are currently open — the two drifted apart and saying
-  // otherwise is how the first version of this comment became false.
-  //
-  // The live BONGOS-V1 open set is 37: goal 1000077 was mapped and renamed while
-  // open and has since been ACHIEVED, so 31 of the 32 entries have an open goal to
-  // apply to (hence the applier's 'applied: 31'), and 31 + 6 = 37 covers every open
-  // goal. A stale entry is harmless — planFor is idempotent and simply never matches.
-  //
-  // Pinned rather than derived on purpose: derived from the live set it would pass
-  // forever and never catch a NEW goal. That pin is what surfaced 1000080.
-  assert.equal(Object.keys(GOAL_NAMES).length + ALREADY_NAMES.length, 38);
-});
-
-test('re-running is a no-op — planFor is idempotent', () => {
-  const want = GOAL_NAMES[1000027];
-  const already = { id: 1000027, title: want.title, subtitle: want.subtitle };
-  assert.deepEqual(planFor(already, want), {}, 'nothing to patch when already correct');
-});
-
-test('planFor patches only what differs', () => {
-  const want = GOAL_NAMES[1000027];
-  const titleOnly = { id: 1, title: 'Findability — the grep path (ADR 0095)', subtitle: want.subtitle };
-  assert.deepEqual(Object.keys(planFor(titleOnly, want)), ['title']);
-  const subOnly = { id: 1, title: want.title, subtitle: '' };
-  assert.deepEqual(Object.keys(planFor(subOnly, want)), ['subtitle']);
-});
-
-test('a NULL subtitle is treated as absent, not as a value', () => {
-  const want = GOAL_NAMES[1000027];
-  const fresh = { id: 1, title: want.title, subtitle: null };
-  assert.deepEqual(Object.keys(planFor(fresh, want)), ['subtitle'], 'null must still be filled in');
-});
-
-test('the version catch-all is named for what it is', () => {
-  const v = GOAL_NAMES[1000003];
-  assert.ok(!/BONGOS-V1/.test(v.title), 'a version id is not a name');
-  assert.ok(!/general/i.test(v.title), '"general" names nothing');
-  assert.match(v.subtitle, /catch-all/i, 'and the subtitle says what it actually is');
-});

package/tests/newcomer_generator.mjs

@@ -1,48 +0,0 @@
-// tests/newcomer_generator.mjs — the daily newcomer-generator routine runs to the end.
-//
-// task 1004860: the routine's artist lane read a curated prompt library from
-// modules/art-pipeline/template/, a module this core no longer carries. The read
-// threw ENOENT, so every run exited 1 straight after the engineer lane. The lane is
-// gone; this drives a whole run through an injected API and checks it finishes.
-
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const { main } = require('../.claude/scheduled-tasks/newcomer-generator/generate.js');
-
-function fakeApi() {
-  const calls = [];
-  const api = async (method, p, body) => {
-    calls.push({ method, p, body });
-    if (method === 'GET' && p.startsWith('/api/bongos/tasks')) return { ok: true, data: { tasks: [] } };
-    if (method === 'GET' && p.startsWith('/api/bongos/inbox')) {
-      return { ok: true, data: { ideas: [{ id: 7, title: 'Tidy a helper', kind: 'cleanup', priority: 5, body_md: 'x' }] } };
-    }
-    if (method === 'POST') return { ok: true, data: { task: { id: 99, title: body.title } } };
-    if (method === 'PATCH') return { ok: true, data: {} };
-    return { ok: false, status: 404, data: {} };
-  };
-  return { api, calls };
-}
-
-test('a below-target run tops up the engineer lane and finishes without reading a prompt library', async () => {
-  // Arrange
-  const { api, calls } = fakeApi();
-  const log = console.log;
-  console.log = () => {};
-
-  // Act
-  try {
-    await main({ apiCall: api });
-  } finally {
-    console.log = log;
-  }
-
-  // Assert
-  const created = calls.filter((c) => c.method === 'POST');
-  assert.equal(created.length, 1, 'exactly one task is created');
-  assert.equal(created[0].body.discipline, 'engineer');
-  assert.ok(calls.some((c) => c.method === 'PATCH' && c.p === '/api/bongos/inbox/7'), 'the idea is marked promoted');
-});