kodelyth-ecc 1.5.10 → 1.7.1

package/tests/evolve/analyze.test.js

@@ -0,0 +1,169 @@
+// Tests for scripts/evolve/analyze.js
+'use strict';
+
+const test   = require('node:test');
+const assert = require('node:assert/strict');
+
+const A = require('../../scripts/evolve/analyze.js');
+
+const FAKE_MEMORY = {
+  id: 'm1',
+  problem: 'Tailwind v4 migration breaks arbitrary values',
+  approach: 'Regenerate config with @config and update postcss-import order',
+  tags: ['css', 'tailwind', 'migration'],
+  language: 'typescript',
+  source: 'manual',
+  captured_at: '2026-04-01T00:00:00Z',
+};
+
+// ── thresholds ──────────────────────────────────────────────────────────────
+
+test('exposes default thresholds', () => {
+  assert.ok(A.DEFAULT_REUSE_MIN_COUNT >= 1);
+  assert.ok(A.DEFAULT_REUSE_MIN_SESSIONS >= 1);
+  assert.ok(A.DEFAULT_MISS_MIN_COUNT >= 1);
+});
+
+// ── analyzeReuseForProposals ────────────────────────────────────────────────
+
+test('analyzeReuseForProposals: skips when below threshold', () => {
+  const reuseStats = {
+    entries: [{ id: 'm1', count: 1, sessions: ['s1'], projects: [] }],
+  };
+  const proposals = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] });
+  assert.equal(proposals.length, 0);
+});
+
+test('analyzeReuseForProposals: emits skill-upgrade when count + sessions clear thresholds', () => {
+  const reuseStats = {
+    entries: [{
+      id: 'm1', count: 4,
+      sessions: ['s1', 's2', 's3', 's4'],
+      projects: ['/p'],
+      firstSurfaced: '2026-04-01T...',
+      lastSurfaced:  '2026-05-01T...',
+    }],
+  };
+  const proposals = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] });
+  assert.equal(proposals.length, 1);
+  const p = proposals[0];
+  assert.equal(p.type, 'skill-upgrade');
+  assert.equal(p.evidence.memoryId, 'm1');
+  assert.equal(p.evidence.reuseCount, 4);
+  assert.match(p.proposal.target_path, /^skills\/tailwind-v4-migration/);
+  assert.match(p.proposal.diff, /## Problem/);
+  assert.match(p.proposal.diff, /Tailwind v4 migration/);
+});
+
+test('analyzeReuseForProposals: thresholds are configurable', () => {
+  const reuseStats = { entries: [{ id: 'm1', count: 2, sessions: ['s1'], projects: [] }] };
+  // Default: needs count>=3 AND sessions>=2 → skip
+  assert.equal(A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] }).length, 0);
+  // Lower thresholds → emit
+  const proposals = A.analyzeReuseForProposals({
+    reuseStats, memories: [FAKE_MEMORY],
+    thresholds: { minCount: 1, minSessions: 1 },
+  });
+  assert.equal(proposals.length, 1);
+});
+
+test('analyzeReuseForProposals: skips memories not present in store', () => {
+  const reuseStats = { entries: [{ id: 'orphan', count: 5, sessions: ['s1', 's2'], projects: [] }] };
+  const proposals = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] });
+  assert.equal(proposals.length, 0);
+});
+
+test('analyzeReuseForProposals: deterministic ID across runs', () => {
+  const reuseStats = { entries: [{ id: 'm1', count: 4, sessions: ['s1', 's2', 's3', 's4'], projects: [] }] };
+  const a = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] })[0];
+  const b = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] })[0];
+  assert.equal(a.id, b.id);
+  assert.match(a.id, /^skill-[0-9a-f]{10}$/);
+});
+
+// ── clusterMisses ───────────────────────────────────────────────────────────
+
+test('clusterMisses: groups by ≥2 token overlap', () => {
+  const entries = [
+    { tokens: ['feature', 'flag', 'gradual', 'rollout'], count: 2, samples: [], hash: 'a' },
+    { tokens: ['feature', 'flag', 'percentage', 'enabled'], count: 1, samples: [], hash: 'b' },
+    { tokens: ['unrelated', 'topic', 'completely', 'different'], count: 1, samples: [], hash: 'c' },
+  ];
+  const clusters = A.clusterMisses(entries);
+  assert.equal(clusters.length, 2, 'two distinct clusters');
+  assert.equal(clusters[0].count, 3, 'feature/flag cluster aggregated count');
+});
+
+test('clusterMisses: single-overlap entries do NOT cluster', () => {
+  const entries = [
+    { tokens: ['alpha', 'beta', 'gamma', 'delta'], count: 1, samples: [], hash: 'a' },
+    { tokens: ['alpha', 'epsilon', 'zeta', 'eta'], count: 1, samples: [], hash: 'b' },
+  ];
+  const clusters = A.clusterMisses(entries);
+  assert.equal(clusters.length, 2);
+});
+
+// ── analyzeMissesForProposals ───────────────────────────────────────────────
+
+test('analyzeMissesForProposals: emits routing-addition when cluster exceeds thresholds', () => {
+  const missStats = {
+    entries: [
+      { tokens: ['feature', 'flag', 'gradual'], count: 2, samples: ['feature flag gradual rollout 1'], hash: 'a' },
+      { tokens: ['feature', 'flag', 'percent'], count: 1, samples: ['feature flag percent enabled'],   hash: 'b' },
+      { tokens: ['feature', 'flag', 'kill'],    count: 1, samples: ['feature flag kill switch'],       hash: 'c' },
+    ],
+  };
+  const proposals = A.analyzeMissesForProposals({ missStats });
+  assert.equal(proposals.length, 1);
+  const p = proposals[0];
+  assert.equal(p.type, 'routing-addition');
+  assert.equal(p.proposal.target_path, 'rules/common/agent-intent-routing.md');
+  assert.match(p.proposal.diff, /TODO-agent/);
+  assert.match(p.proposal.diff, /feature/);
+});
+
+test('analyzeMissesForProposals: skips clusters below threshold', () => {
+  const missStats = { entries: [{ tokens: ['x', 'y', 'z'], count: 1, samples: [], hash: 'a' }] };
+  const proposals = A.analyzeMissesForProposals({ missStats });
+  assert.equal(proposals.length, 0);
+});
+
+// ── analyzeAll ──────────────────────────────────────────────────────────────
+
+test('analyzeAll: combines reuse + miss proposals', () => {
+  const out = A.analyzeAll({
+    reuseStats: { entries: [{ id: 'm1', count: 4, sessions: ['s1', 's2', 's3', 's4'], projects: [] }] },
+    missStats:  { entries: [
+      { tokens: ['database', 'vacuum', 'job'], count: 2, samples: ['database vacuum job 1'], hash: 'a' },
+      { tokens: ['database', 'vacuum', 'big'], count: 1, samples: ['database vacuum big table'], hash: 'b' },
+      { tokens: ['database', 'vacuum', 'fast'], count: 1, samples: ['database vacuum fast'], hash: 'c' },
+    ] },
+    memories:   [FAKE_MEMORY],
+  });
+  const types = out.map(p => p.type).sort();
+  assert.deepEqual(types, ['routing-addition', 'skill-upgrade']);
+});
+
+test('analyzeAll: empty inputs → empty output', () => {
+  assert.deepEqual(
+    A.analyzeAll({ reuseStats: { entries: [] }, missStats: { entries: [] }, memories: [] }),
+    []
+  );
+});
+
+// ── slugify edge cases ─────────────────────────────────────────────────────
+
+test('_internals.slugify: empty fallback', () => {
+  assert.equal(A._internals.slugify(''), 'untitled');
+  assert.equal(A._internals.slugify(null), 'untitled');
+  assert.equal(A._internals.slugify(undefined), 'untitled');
+});
+
+test('_internals.slugify: caps length', () => {
+  const s = A._internals.slugify('a'.repeat(200));
+  assert.ok(s.length <= 60);
+});
+
+test('_internals.slugify: special chars normalized', () => {
+  assert.equal(A._internals.slugify('Hello, World! 2026'), 'hello-world-2026');
+});

package/tests/evolve/proposals.test.js

@@ -0,0 +1,173 @@
+// Tests for scripts/evolve/proposals.js
+'use strict';
+
+const test   = require('node:test');
+const assert = require('node:assert/strict');
+const fs     = require('node:fs');
+const os     = require('node:os');
+const path   = require('node:path');
+
+const P = require('../../scripts/evolve/proposals.js');
+
+function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-evolve-prop-')); }
+function cleanup(dir) { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ } }
+
+const FAKE_PROPOSAL = {
+  id: 'skill-abc123',
+  type: 'skill-upgrade',
+  evidence: { memoryId: 'm1', reuseCount: 5 },
+  proposal: {
+    kind: 'create-skill',
+    target_path: 'skills/test-skill/SKILL.md',
+    diff: '# test skill\n\nbody\n',
+    rationale: 'because reuse',
+  },
+};
+
+// ── appendProposal ──────────────────────────────────────────────────────────
+
+test('appendProposal: rejects malformed input', () => {
+  const d = tmpDir();
+  try {
+    assert.throws(() => P.appendProposal({}, d), /must include id, type/);
+    assert.throws(() => P.appendProposal({ id: 'x' }, d), /must include id, type/);
+  } finally { cleanup(d); }
+});
+
+test('appendProposal: writes pending entry on first call', () => {
+  const d = tmpDir();
+  try {
+    const r = P.appendProposal(FAKE_PROPOSAL, d);
+    assert.equal(r.status, 'pending');
+    assert.ok(r.created_at);
+    const all = P.readLatest(d);
+    assert.equal(all.length, 1);
+    assert.equal(all[0].id, 'skill-abc123');
+  } finally { cleanup(d); }
+});
+
+test('appendProposal: idempotent on same id', () => {
+  const d = tmpDir();
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    P.appendProposal(FAKE_PROPOSAL, d);
+    P.appendProposal(FAKE_PROPOSAL, d);
+    const all = P.readLatest(d);
+    assert.equal(all.length, 1, 'no duplicates');
+    const events = P.readAll(d);
+    assert.equal(events.length, 1, 'only one event written');
+  } finally { cleanup(d); }
+});
+
+// ── setStatus ───────────────────────────────────────────────────────────────
+
+test('setStatus: rejects invalid status', () => {
+  const d = tmpDir();
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    assert.throws(() => P.setStatus('skill-abc123', 'banana', d), /invalid status/);
+  } finally { cleanup(d); }
+});
+
+test('setStatus: returns null for unknown id', () => {
+  const d = tmpDir();
+  try {
+    assert.equal(P.setStatus('does-not-exist', 'accepted', d), null);
+  } finally { cleanup(d); }
+});
+
+test('setStatus: transitions pending → accepted, preserves diff/evidence', () => {
+  const d = tmpDir();
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    const r = P.setStatus('skill-abc123', 'accepted', d, { applied_path: '/tmp/foo.md' });
+    assert.equal(r.status, 'accepted');
+    assert.equal(r.applied_path, '/tmp/foo.md');
+
+    const cur = P.findById('skill-abc123', d);
+    assert.equal(cur.status, 'accepted');
+    assert.equal(cur.applied_path, '/tmp/foo.md');
+    // Original proposal data preserved.
+    assert.equal(cur.proposal.target_path, 'skills/test-skill/SKILL.md');
+    assert.equal(cur.evidence.reuseCount, 5);
+  } finally { cleanup(d); }
+});
+
+test('setStatus: pending → rejected → accepted preserves audit trail', () => {
+  const d = tmpDir();
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    P.setStatus('skill-abc123', 'rejected', d, { note: 'no thanks' });
+    P.setStatus('skill-abc123', 'accepted', d, { applied_path: '/x' });
+    const events = P.readAll(d);
+    assert.equal(events.length, 3, '3 events: append, reject, accept');
+    assert.equal(P.findById('skill-abc123', d).status, 'accepted');
+  } finally { cleanup(d); }
+});
+
+// ── listByStatus / findById ─────────────────────────────────────────────────
+
+test('listByStatus: filters latest state', () => {
+  const d = tmpDir();
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    P.appendProposal({ ...FAKE_PROPOSAL, id: 'skill-second' }, d);
+    P.setStatus('skill-second', 'accepted', d);
+    assert.equal(P.listByStatus('pending', d).length, 1);
+    assert.equal(P.listByStatus('accepted', d).length, 1);
+    assert.equal(P.listByStatus(null, d).length, 2);
+  } finally { cleanup(d); }
+});
+
+test('findById: returns null when absent', () => {
+  const d = tmpDir();
+  try {
+    assert.equal(P.findById('nope', d), null);
+  } finally { cleanup(d); }
+});
+
+// ── applyProposalToDisk ─────────────────────────────────────────────────────
+
+test('applyProposalToDisk: writes diff to target_path under repoRoot', () => {
+  const d = tmpDir();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-apply-'));
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    const proposal = P.findById('skill-abc123', d);
+    const r = P.applyProposalToDisk(proposal, { repoRoot: root });
+    assert.equal(r.written, true);
+    assert.ok(fs.existsSync(r.path));
+    assert.equal(fs.readFileSync(r.path, 'utf8'), '# test skill\n\nbody\n');
+  } finally { cleanup(d); cleanup(root); }
+});
+
+test('applyProposalToDisk: refuses to overwrite without --overwrite', () => {
+  const d = tmpDir();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-apply-'));
+  try {
+    P.appendProposal(FAKE_PROPOSAL, d);
+    const proposal = P.findById('skill-abc123', d);
+    P.applyProposalToDisk(proposal, { repoRoot: root });
+    assert.throws(
+      () => P.applyProposalToDisk(proposal, { repoRoot: root }),
+      /refusing to overwrite/
+    );
+    // overwrite=true succeeds
+    const r = P.applyProposalToDisk({
+      ...proposal,
+      proposal: { ...proposal.proposal, diff: 'new content' },
+    }, { repoRoot: root, overwrite: true });
+    assert.equal(fs.readFileSync(r.path, 'utf8'), 'new content');
+  } finally { cleanup(d); cleanup(root); }
+});
+
+test('applyProposalToDisk: requires repoRoot', () => {
+  assert.throws(() => P.applyProposalToDisk(FAKE_PROPOSAL, {}), /repoRoot is required/);
+});
+
+test('applyProposalToDisk: rejects proposal without diff/target_path', () => {
+  assert.throws(
+    () => P.applyProposalToDisk({ id: 'x', proposal: {} }, { repoRoot: '/tmp' }),
+    /lacks diff or target_path/
+  );
+});

package/tests/evolve/stats.test.js

@@ -0,0 +1,167 @@
+// Tests for scripts/evolve/stats.js
+'use strict';
+
+const test   = require('node:test');
+const assert = require('node:assert/strict');
+const fs     = require('node:fs');
+const os     = require('node:os');
+const path   = require('node:path');
+
+const stats = require('../../scripts/evolve/stats.js');
+
+function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-evolve-stats-')); }
+function cleanup(dir) { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ } }
+
+// ── recordSurface ────────────────────────────────────────────────────────────
+
+test('recordSurface: rejects missing memoryId', () => {
+  const d = tmpDir();
+  try {
+    assert.equal(stats.recordSurface({ sessionId: 's1' }, d), false);
+  } finally { cleanup(d); }
+});
+
+test('recordSurface: bumps count on first session, idempotent within same session', () => {
+  const d = tmpDir();
+  try {
+    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/proj' }, d), true);
+    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/proj' }, d), true);
+    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/proj' }, d), true);
+
+    const r = stats.getReuseStats(d);
+    assert.equal(r.total_memories_tracked, 1);
+    assert.equal(r.total_surfaces, 1, 'same session should only count once');
+    assert.equal(r.entries[0].count, 1);
+    assert.deepEqual(r.entries[0].sessions, ['s1']);
+    assert.deepEqual(r.entries[0].projects, ['/proj']);
+  } finally { cleanup(d); }
+});
+
+test('recordSurface: bumps count on each new session', () => {
+  const d = tmpDir();
+  try {
+    for (let i = 0; i < 4; i++) {
+      stats.recordSurface({ memoryId: 'm1', sessionId: `s${i}` }, d);
+    }
+    const r = stats.getReuseStats(d);
+    assert.equal(r.entries[0].count, 4);
+    assert.equal(r.entries[0].sessions.length, 4);
+  } finally { cleanup(d); }
+});
+
+test('recordSurface: tracks distinct projects without duplicating', () => {
+  const d = tmpDir();
+  try {
+    stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/a' }, d);
+    stats.recordSurface({ memoryId: 'm1', sessionId: 's2', projectRoot: '/a' }, d);
+    stats.recordSurface({ memoryId: 'm1', sessionId: 's3', projectRoot: '/b' }, d);
+    const r = stats.getReuseStats(d);
+    assert.deepEqual(r.entries[0].projects, ['/a', '/b']);
+  } finally { cleanup(d); }
+});
+
+test('recordSurface: never throws on bad dir; returns false', () => {
+  // Create a file then pass a subpath of it as the dir — fails on all platforms
+  // because mkdirSync can't create a directory where a file already exists.
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-stats-bad-'));
+  const fileAsDir = path.join(tmp, 'not-a-dir');
+  fs.writeFileSync(fileAsDir, 'x');
+  try {
+    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1' }, path.join(fileAsDir, 'sub')), false);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ── recordRoutingMiss ────────────────────────────────────────────────────────
+
+test('recordRoutingMiss: rejects empty prompt', () => {
+  const d = tmpDir();
+  try {
+    assert.equal(stats.recordRoutingMiss({ prompt: '', sessionId: 's1' }, d), false);
+    assert.equal(stats.recordRoutingMiss({ sessionId: 's1' }, d), false);
+  } finally { cleanup(d); }
+});
+
+test('recordRoutingMiss: appends one line per call', () => {
+  const d = tmpDir();
+  try {
+    stats.recordRoutingMiss({ prompt: 'how do I reset postgres replication',  sessionId: 's1' }, d);
+    stats.recordRoutingMiss({ prompt: 'postgres logical replication is stuck', sessionId: 's2' }, d);
+    const m = stats.getRoutingMissStats(d);
+    assert.equal(m.total_misses, 2);
+    assert.equal(m.unique_prompts, 2);
+    assert.ok(m.entries.every(e => Array.isArray(e.tokens) && e.tokens.length > 0));
+  } finally { cleanup(d); }
+});
+
+test('recordRoutingMiss: same prompt aggregates by hash', () => {
+  const d = tmpDir();
+  try {
+    stats.recordRoutingMiss({ prompt: 'identical prompt body', sessionId: 's1' }, d);
+    stats.recordRoutingMiss({ prompt: 'identical prompt body', sessionId: 's2' }, d);
+    stats.recordRoutingMiss({ prompt: 'identical prompt body', sessionId: 's3' }, d);
+    const m = stats.getRoutingMissStats(d);
+    assert.equal(m.total_misses, 3);
+    assert.equal(m.unique_prompts, 1);
+    assert.equal(m.entries[0].count, 3);
+  } finally { cleanup(d); }
+});
+
+test('recordRoutingMiss: caps stored prompt to 1000 chars', () => {
+  const d = tmpDir();
+  try {
+    const huge = 'x'.repeat(5000);
+    stats.recordRoutingMiss({ prompt: huge, sessionId: 's1' }, d);
+    const m = stats.getRoutingMissStats(d);
+    assert.equal(m.entries[0].samples[0].length, 1000);
+  } finally { cleanup(d); }
+});
+
+// ── empty / readback ────────────────────────────────────────────────────────
+
+test('readReuse on empty dir returns sane defaults', () => {
+  const d = tmpDir();
+  try {
+    const r = stats.readReuse(d);
+    assert.deepEqual(r.byMemory, {});
+    assert.equal(r.lastUpdated, null);
+  } finally { cleanup(d); }
+});
+
+test('getRoutingMissStats on empty dir returns empty arrays', () => {
+  const d = tmpDir();
+  try {
+    const m = stats.getRoutingMissStats(d);
+    assert.equal(m.total_misses, 0);
+    assert.equal(m.unique_prompts, 0);
+    assert.deepEqual(m.entries, []);
+  } finally { cleanup(d); }
+});
+
+test('resetAll clears both stores', () => {
+  const d = tmpDir();
+  try {
+    stats.recordSurface({ memoryId: 'm', sessionId: 's' }, d);
+    stats.recordRoutingMiss({ prompt: 'something here', sessionId: 's' }, d);
+    assert.equal(stats.resetAll(d), true);
+    assert.equal(stats.getReuseStats(d).total_memories_tracked, 0);
+    assert.equal(stats.getRoutingMissStats(d).total_misses, 0);
+  } finally { cleanup(d); }
+});
+
+// ── tokenize / hash ──────────────────────────────────────────────────────────
+
+test('_internals.tokenize lowercases and splits', () => {
+  const out = stats._internals.tokenize('Hello, World! foo-bar/baz');
+  assert.ok(out.includes('hello'));
+  assert.ok(out.includes('world'));
+  assert.ok(out.includes('foo-bar/baz') || out.includes('foo-bar') || out.includes('baz'));
+});
+
+test('_internals.hashPrompt is stable + 12 hex chars', () => {
+  const a = stats._internals.hashPrompt('hello');
+  const b = stats._internals.hashPrompt('hello');
+  assert.equal(a, b);
+  assert.match(a, /^[0-9a-f]{12}$/);
+});

package/tests/mcp/catalog.test.js

@@ -0,0 +1,98 @@
+// Tests for scripts/mcp/catalog.js — read-only loader for ECC catalog files.
+'use strict';
+
+const test   = require('node:test');
+const assert = require('node:assert/strict');
+
+const catalog = require('../../scripts/mcp/catalog');
+
+test('parseFrontmatter parses simple key/value', () => {
+  const { meta, body } = catalog.parseFrontmatter('---\nname: foo\ndescription: bar\n---\nhello');
+  assert.equal(meta.name, 'foo');
+  assert.equal(meta.description, 'bar');
+  assert.equal(body, 'hello');
+});
+
+test('parseFrontmatter handles folded scalar (>)', () => {
+  const raw = '---\nname: x\ndescription: >\n  line one\n  line two\n---\n# body';
+  const { meta, body } = catalog.parseFrontmatter(raw);
+  assert.equal(meta.name, 'x');
+  assert.match(meta.description, /line one/);
+  assert.match(meta.description, /line two/);
+  assert.equal(body, '# body');
+});
+
+test('parseFrontmatter handles missing frontmatter', () => {
+  const { meta, body } = catalog.parseFrontmatter('# just markdown');
+  assert.deepEqual(meta, {});
+  assert.equal(body, '# just markdown');
+});
+
+test('loadAgents finds at least one known agent', () => {
+  const agents = catalog.loadAgents();
+  assert.ok(Array.isArray(agents));
+  assert.ok(agents.length >= 60, `expected >=60 agents, got ${agents.length}`);
+  const dd = agents.find(a => a.name === 'debug-detective');
+  assert.ok(dd, 'debug-detective agent must be present');
+  assert.ok(dd.description.length > 0);
+  assert.ok(dd.body.length > 100);
+});
+
+test('loadAgents includes the new devil-mode crew', () => {
+  const agents = catalog.loadAgents();
+  const names = new Set(agents.map(a => a.name));
+  for (const expected of [
+    'prompt-injection-hunter',
+    'supply-chain-auditor',
+    'jailbreak-tester',
+    'backdoor-hunter',
+    'chaos-engineer',
+  ]) {
+    assert.ok(names.has(expected), `missing devil-mode agent: ${expected}`);
+  }
+});
+
+test('loadSkills returns a populated list with descriptions', () => {
+  const skills = catalog.loadSkills();
+  assert.ok(skills.length >= 100, `expected >=100 skills, got ${skills.length}`);
+  const ae = skills.find(s => s.name === 'agentic-engineering');
+  assert.ok(ae, 'agentic-engineering skill must be present');
+  assert.ok(ae.description.length > 0);
+});
+
+test('loadCommands returns commands and supports findCommand with leading slash', () => {
+  const cmds = catalog.loadCommands();
+  assert.ok(cmds.length >= 50);
+  const found1 = catalog.findCommand('code-review');
+  const found2 = catalog.findCommand('/code-review');
+  assert.ok(found1 && found2 && found1.name === found2.name);
+});
+
+test('loadAllRules returns the intent routing rule', () => {
+  const rules = catalog.loadAllRules();
+  const r = rules.find(x => x.name === 'agent-intent-routing');
+  assert.ok(r, 'agent-intent-routing rule must be present');
+  assert.ok(r.body.length > 500);
+});
+
+test('loadBundles returns the three power bundles', () => {
+  const bundles = catalog.loadBundles();
+  const names = new Set(bundles.map(b => b.name));
+  assert.ok(names.has('indie-hacker'));
+  assert.ok(names.has('red-team'));
+  assert.ok(names.has('enterprise'));
+});
+
+test('stats returns expected fields', () => {
+  const s = catalog.stats();
+  assert.ok(typeof s.agents === 'number' && s.agents > 0);
+  assert.ok(typeof s.skills === 'number' && s.skills > 0);
+  assert.ok(typeof s.commands === 'number' && s.commands > 0);
+  assert.ok(typeof s.rules === 'number' && s.rules > 0);
+  assert.ok(typeof s.bundles === 'number');
+  assert.ok(typeof s.root === 'string');
+});
+
+test('findAgent returns null for unknown name', () => {
+  assert.equal(catalog.findAgent('this-agent-does-not-exist'), null);
+});