@sdsrs/code-graph 0.93.1 → 0.95.0

package/claude-plugin/scripts/cg-answer.test.js

@@ -1,309 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { runGrepAnswer, runShowAnswer, runOverviewAnswer, runCallgraphAnswer, truncateAtLine } = require('./cg-answer');
-
-// Stub "binary": a node script that reacts to its first real arg so one stub
-// covers hits / no-hits / error / timeout cases.
-let stubDir;
-let stubPath;
-
-test.before(() => {
-  stubDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-answer-test-'));
-  stubPath = path.join(stubDir, 'cg-stub.js');
-  fs.writeFileSync(stubPath, `#!/usr/bin/env node
-'use strict';
-const pattern = process.argv[3] || '';
-if (pattern === 'HangForever') { setTimeout(() => {}, 60000); }
-else if (pattern === 'ExplodePlease') { process.exit(3); }
-else if (pattern === 'NothingHere') {
-  process.stdout.write('[code-graph] No matches for: NothingHere\\n');
-} else if (pattern === 'NothingHereExit1') {
-  // v0.50 grep-parity binary: no match → empty stdout + exit 1
-  process.exit(1);
-} else if (pattern === 'HasCallers') {
-  // callgraph with real edges → runCallgraphAnswer 'hits'
-  process.stdout.write(
-    'HasCallers (src/a.rs)\\n' +
-    '  \\u2190 called by: alpha (src/b.rs)\\n' +
-    '  \\u2192 calls: beta (src/c.rs)\\n');
-} else if (pattern === 'LeafSymbol') {
-  // callgraph with a bare header, no edge lines → 'no-hits' (no marginal value)
-  process.stdout.write('LeafSymbol (src/a.rs)\\n');
-} else {
-  process.stdout.write(
-    'src/storage/db.rs:42  fn ' + pattern + '() {\\n' +
-    '  -> fn ' + pattern + ' (lines 42-60)\\n' +
-    'args=' + JSON.stringify(process.argv.slice(2)) + '\\n');
-}
-`);
-});
-
-test.after(() => {
-  fs.rmSync(stubDir, { recursive: true, force: true });
-});
-
-// Wrap the stub so spawnSync can exec it directly: binary = node, leading arg
-// trick is not possible (runGrepAnswer controls args), so expose via a shim
-// shell-free approach: point binary at node and prepend the script through
-// _CG_ANSWER_BINARY handling is binary-only. Instead make the stub itself
-// executable with a node shebang and rely on exec.
-function stubBinary() {
-  fs.chmodSync(stubPath, 0o755);
-  return stubPath;
-}
-
-test('runGrepAnswer: hits → status hits with stdout text', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'fts5_search', binary: stubBinary() });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /fn fts5_search/);
-});
-
-test('runGrepAnswer: passes grep subcommand, pattern and path as argv', () => {
-  const r = runGrepAnswer({
-    cwd: stubDir, pattern: 'fts5_search', searchPath: 'src/storage/', binary: stubBinary(),
-  });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /args=\["grep","fts5_search","src\/storage\/"\]/);
-});
-
-test('runGrepAnswer: child env carries CODE_GRAPH_INTERNAL=1 (not a funnel conversion)', () => {
-  // Stub variant that echoes the marker back in its output.
-  const envStub = path.join(stubDir, 'cg-env-stub.js');
-  fs.writeFileSync(envStub, `#!/usr/bin/env node
-process.stdout.write('internal=' + (process.env.CODE_GRAPH_INTERNAL || '') + '\\n');
-`);
-  fs.chmodSync(envStub, 0o755);
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'whatever', binary: envStub });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /internal=1/,
-    'hook-internal CLI runs must be marked so record_cli_use skips them');
-});
-
-test('runGrepAnswer: omits path argv when no searchPath', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'fts5_search', binary: stubBinary() });
-  assert.match(r.text, /args=\["grep","fts5_search"\]/);
-});
-
-test('runGrepAnswer: CLI "[code-graph] No matches" → status no-hits', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'NothingHere', binary: stubBinary() });
-  assert.equal(r.status, 'no-hits');
-});
-
-test('runGrepAnswer: exit 1 (v0.50 grep-parity no-match) → status no-hits', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'NothingHereExit1', binary: stubBinary() });
-  assert.equal(r.status, 'no-hits',
-    'grep-parity exit 1 means no match, not a failed binary');
-});
-
-test('runGrepAnswer: exit >1 → unavailable', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'ExplodePlease', binary: stubBinary() });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runGrepAnswer: missing binary → no-binary (distinct from runtime unavailable)', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'fts5_search', binary: null });
-  assert.equal(r.status, 'no-binary',
-    'a null binary is the flagship-dark case and must be distinguishable from a runtime failure');
-});
-
-test('runGrepAnswer: nonexistent binary path → unavailable (spawn failure, not no-binary)', () => {
-  // A non-null path that fails to spawn is a runtime failure, NOT a missing
-  // binary — `no-binary` is reserved for findBinary() returning falsy.
-  const r = runGrepAnswer({
-    cwd: stubDir, pattern: 'fts5_search', binary: path.join(stubDir, 'nope-bin'),
-  });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runGrepAnswer: timeout → unavailable', () => {
-  const r = runGrepAnswer({
-    cwd: stubDir, pattern: 'HangForever', binary: stubBinary(), timeoutMs: 300,
-  });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runGrepAnswer: empty pattern → unavailable (never spawns)', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: '', binary: stubBinary() });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runGrepAnswer: oversized pattern (>200ch) → unavailable (never spawns)', () => {
-  const r = runGrepAnswer({ cwd: stubDir, pattern: 'A'.repeat(201), binary: stubBinary() });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runGrepAnswer: long output is truncated with marker', () => {
-  // Stub echoes args= line; force truncation via tiny maxBytes
-  const r = runGrepAnswer({
-    cwd: stubDir, pattern: 'fts5_search', binary: stubBinary(), maxBytes: 30,
-  });
-  assert.equal(r.status, 'hits');
-  assert.equal(r.truncated, true);
-  assert.ok(Buffer.byteLength(r.text, 'utf8') <= 30);
-});
-
-// ── truncateAtLine (pure) ───────────────────────────────────────────
-
-test('truncateAtLine: under limit → unchanged, not truncated', () => {
-  const { text, truncated } = truncateAtLine('a\nb\nc', 100);
-  assert.equal(text, 'a\nb\nc');
-  assert.equal(truncated, false);
-});
-
-test('truncateAtLine: cuts at a line boundary', () => {
-  const input = 'line-one\nline-two\nline-three\n';
-  const { text, truncated } = truncateAtLine(input, 20);
-  assert.equal(truncated, true);
-  // 20-byte budget fits 'line-one\nline-two' (17B); the half-cut 'li' is dropped
-  assert.equal(text, 'line-one\nline-two');
-});
-
-test('truncateAtLine: single oversized line → hard cut', () => {
-  const { text, truncated } = truncateAtLine('x'.repeat(50), 10);
-  assert.equal(truncated, true);
-  assert.equal(Buffer.byteLength(text, 'utf8'), 10);
-});
-
-// ── v0.48 sanitizeSearchPath: glob args reach rg literally (no shell) ──
-
-test('sanitizeSearchPath: truncates at first glob segment (daagu denied command)', () => {
-  const { sanitizeSearchPath } = require('./cg-answer');
-  assert.equal(
-    sanitizeSearchPath('backend/app/services/llm_engine/*.py'),
-    'backend/app/services/llm_engine');
-});
-
-test('sanitizeSearchPath: clean path unchanged; leading glob drops scope; falsy → undefined', () => {
-  const { sanitizeSearchPath } = require('./cg-answer');
-  assert.equal(sanitizeSearchPath('src/storage/'), 'src/storage/');
-  assert.equal(sanitizeSearchPath('*.py'), undefined);
-  assert.equal(sanitizeSearchPath('src/**/x.rs'), 'src');
-  assert.equal(sanitizeSearchPath('src/file[1].rs'), 'src');
-  assert.equal(sanitizeSearchPath(''), undefined);
-  assert.equal(sanitizeSearchPath(undefined), undefined);
-});
-
-test('runGrepAnswer: glob searchPath is truncated before spawn (defensive layer)', () => {
-  const r = runGrepAnswer({
-    cwd: stubDir, pattern: 'fts5_search', searchPath: 'src/storage/*.rs', binary: stubBinary(),
-  });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /args=\["grep","fts5_search","src\/storage"\]/);
-});
-
-// ── runShowAnswer (v0.49) — show-mode deny bodies ────────────────────
-
-test('runShowAnswer: concatenates per-symbol show output with $ headers', () => {
-  const r = runShowAnswer({ cwd: stubDir, symbols: ['alpha_one', 'beta_two'], binary: stubBinary() });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /\$ code-graph-mcp show alpha_one/);
-  assert.match(r.text, /\$ code-graph-mcp show beta_two/);
-});
-
-test('runShowAnswer: skips non-identifier symbols, all-skipped → unavailable-safe no-hits', () => {
-  const r = runShowAnswer({ cwd: stubDir, symbols: ['$(rm -rf)', 'a|b'], binary: stubBinary() });
-  assert.equal(r.status, 'no-hits');
-});
-
-test('runShowAnswer: caps at 3 symbols', () => {
-  const r = runShowAnswer({
-    cwd: stubDir, symbols: ['s_one', 's_two', 's_three', 's_four'], binary: stubBinary(),
-  });
-  assert.equal(r.status, 'hits');
-  assert.doesNotMatch(r.text, /show s_four/);
-});
-
-test('runShowAnswer: empty symbol list → unavailable', () => {
-  assert.equal(runShowAnswer({ cwd: stubDir, symbols: [], binary: stubBinary() }).status, 'unavailable');
-});
-
-test('runShowAnswer: failing binary → no-hits (caller falls back to grep answer)', () => {
-  const r = runShowAnswer({ cwd: stubDir, symbols: ['ExplodePlease'], binary: stubBinary() });
-  assert.equal(r.status, 'no-hits');
-});
-
-test('runShowAnswer: missing binary → no-binary (distinct from runtime no-hits/unavailable)', () => {
-  const r = runShowAnswer({ cwd: stubDir, symbols: ['alpha_one'], binary: null });
-  assert.equal(r.status, 'no-binary');
-});
-
-// ── runOverviewAnswer (v0.49) — read-fanout delivered module map ──────
-
-test('runOverviewAnswer: hits → status hits with stdout text', () => {
-  const r = runOverviewAnswer({ cwd: stubDir, dir: 'src/storage', binary: stubBinary() });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /args=\["overview","src\/storage"\]/);
-});
-
-test('runOverviewAnswer: CLI "No matches" → no-hits', () => {
-  const r = runOverviewAnswer({ cwd: stubDir, dir: 'NothingHere', binary: stubBinary() });
-  assert.equal(r.status, 'no-hits');
-});
-
-test('runOverviewAnswer: failing binary → unavailable', () => {
-  const r = runOverviewAnswer({ cwd: stubDir, dir: 'ExplodePlease', binary: stubBinary() });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runOverviewAnswer: missing binary → no-binary (distinct from runtime unavailable)', () => {
-  const r = runOverviewAnswer({ cwd: stubDir, dir: 'src/storage', binary: null });
-  assert.equal(r.status, 'no-binary');
-});
-
-test('runOverviewAnswer: empty/oversized dir → unavailable (never spawns)', () => {
-  assert.equal(runOverviewAnswer({ cwd: stubDir, dir: '', binary: stubBinary() }).status, 'unavailable');
-  assert.equal(
-    runOverviewAnswer({ cwd: stubDir, dir: 'a'.repeat(301), binary: stubBinary() }).status,
-    'unavailable');
-});
-
-// ── runCallgraphAnswer (v0.75) — cross-file caller/callee tree ────────
-
-test('runCallgraphAnswer: edge-bearing tree → hits with caller/callee lines', () => {
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HasCallers', binary: stubBinary() });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /called by: alpha/);
-  assert.match(r.text, /calls: beta/);
-});
-
-test('runCallgraphAnswer: passes callgraph subcommand + symbol as argv', () => {
-  // 'HasCallers' is the only stub branch that emits edges; assert it reached it.
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HasCallers', binary: stubBinary() });
-  assert.equal(r.status, 'hits');
-  assert.match(r.text, /← called by/);
-});
-
-test('runCallgraphAnswer: bare header with no edges → no-hits (no marginal value)', () => {
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'LeafSymbol', binary: stubBinary() });
-  assert.equal(r.status, 'no-hits');
-});
-
-test('runCallgraphAnswer: symbol not in graph (exit 1) → no-hits', () => {
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'NothingHereExit1', binary: stubBinary() });
-  assert.equal(r.status, 'no-hits');
-});
-
-test('runCallgraphAnswer: failing binary → unavailable', () => {
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'ExplodePlease', binary: stubBinary() });
-  assert.equal(r.status, 'unavailable');
-});
-
-test('runCallgraphAnswer: missing binary → no-binary (distinct from runtime unavailable)', () => {
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HasCallers', binary: null });
-  assert.equal(r.status, 'no-binary');
-});
-
-test('runCallgraphAnswer: non-identifier symbol → unavailable (never spawns)', () => {
-  assert.equal(runCallgraphAnswer({ cwd: stubDir, symbol: 'a|b', binary: stubBinary() }).status, 'unavailable');
-  assert.equal(runCallgraphAnswer({ cwd: stubDir, symbol: '', binary: stubBinary() }).status, 'unavailable');
-  assert.equal(runCallgraphAnswer({ cwd: stubDir, symbol: 'def foo', binary: stubBinary() }).status, 'unavailable');
-});
-
-test('runCallgraphAnswer: timeout → unavailable', () => {
-  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HangForever', binary: stubBinary(), timeoutMs: 300 });
-  assert.equal(r.status, 'unavailable');
-});

package/claude-plugin/scripts/claude-config.test.js

@@ -1,58 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('path');
-const os = require('os');
-const { claudeHome } = require('./claude-config');
-
-test('claudeHome defaults to ~/.claude when CLAUDE_CONFIG_DIR unset', () => {
-  const prev = process.env.CLAUDE_CONFIG_DIR;
-  delete process.env.CLAUDE_CONFIG_DIR;
-  try {
-    assert.strictEqual(claudeHome(), path.join(os.homedir(), '.claude'));
-  } finally {
-    if (prev !== undefined) process.env.CLAUDE_CONFIG_DIR = prev;
-  }
-});
-
-test('claudeHome honors CLAUDE_CONFIG_DIR when set', () => {
-  const prev = process.env.CLAUDE_CONFIG_DIR;
-  process.env.CLAUDE_CONFIG_DIR = '/tmp/work-claude';
-  try {
-    assert.strictEqual(claudeHome(), '/tmp/work-claude');
-  } finally {
-    if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
-    else process.env.CLAUDE_CONFIG_DIR = prev;
-  }
-});
-
-test('claudeHome re-reads env on every call (not cached)', () => {
-  const prev = process.env.CLAUDE_CONFIG_DIR;
-  delete process.env.CLAUDE_CONFIG_DIR;
-  try {
-    const before = claudeHome();
-    process.env.CLAUDE_CONFIG_DIR = '/tmp/account-A';
-    const during = claudeHome();
-    delete process.env.CLAUDE_CONFIG_DIR;
-    const after = claudeHome();
-    assert.strictEqual(before, path.join(os.homedir(), '.claude'));
-    assert.strictEqual(during, '/tmp/account-A');
-    assert.strictEqual(after, path.join(os.homedir(), '.claude'));
-  } finally {
-    if (prev !== undefined) process.env.CLAUDE_CONFIG_DIR = prev;
-  }
-});
-
-test('claudeHome ignores empty CLAUDE_CONFIG_DIR (falls back to ~/.claude)', () => {
-  // Empty string is falsy in JS — sanity-check the `||` fallback path so an
-  // accidentally `CLAUDE_CONFIG_DIR=` (unset-style) shell line does not strand
-  // us writing to the literal repository root `/`.
-  const prev = process.env.CLAUDE_CONFIG_DIR;
-  process.env.CLAUDE_CONFIG_DIR = '';
-  try {
-    assert.strictEqual(claudeHome(), path.join(os.homedir(), '.claude'));
-  } finally {
-    if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
-    else process.env.CLAUDE_CONFIG_DIR = prev;
-  }
-});

package/claude-plugin/scripts/covering-tests.test.js

@@ -1,78 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const { formatCoveringTests, LIST_CAP } = require('./covering-tests');
-
-// ── empty / robust ──────────────────────────────────────
-
-test('covering: empty list → no output', () => {
-  assert.equal(formatCoveringTests([], 'src/a.rs'), '');
-});
-
-test('covering: missing/undefined → no output (never throws)', () => {
-  assert.equal(formatCoveringTests(undefined, 'src/a.rs'), '');
-  assert.equal(formatCoveringTests(null, 'src/a.rs'), '');
-});
-
-test('covering: entries without a name are dropped', () => {
-  const out = formatCoveringTests(
-    [{ name: 'test_real', file: 'tests/a.rs' }, { file: 'tests/nameless.rs' }],
-    'src/a.rs'
-  );
-  assert.match(out, /Covering tests \(1\)/); // only the named one counts
-  assert.match(out, /test_real/);
-});
-
-// ── Rust: a real targeted command ───────────────────────
-
-test('covering: Rust ≤cap lists names + a targeted `cargo test` command', () => {
-  const out = formatCoveringTests(
-    [
-      { name: 'test_alpha', file: 'tests/a.rs' },
-      { name: 'test_beta', file: 'src/b.rs' },
-    ],
-    'src/foo.rs'
-  );
-  assert.match(out, /Covering tests \(2\)/);
-  assert.match(out, /test_alpha \(tests\/a\.rs\)/);
-  assert.match(out, /test_beta \(src\/b\.rs\)/);
-  // The actionable part: a command that runs exactly the covering tests.
-  assert.match(out, /Run after editing: cargo test test_alpha test_beta/);
-});
-
-// ── non-Rust: list only, never a fabricated command ─────
-
-test('covering: non-Rust ≤cap lists names but emits NO command (no wrong command)', () => {
-  const out = formatCoveringTests(
-    [{ name: 'testValidate', file: 'src/auth.test.ts' }],
-    'src/auth.ts'
-  );
-  assert.match(out, /Covering tests \(1\): testValidate \(src\/auth\.test\.ts\)/);
-  assert.doesNotMatch(out, /cargo test/);
-  assert.doesNotMatch(out, /Run after editing/);
-});
-
-// ── high fan-out: collapse, point at the suite ──────────
-
-test('covering: Rust high fan-out (>cap) collapses to a count + suite command, no name list', () => {
-  const many = Array.from({ length: LIST_CAP + 1 }, (_, i) => ({
-    name: `test_${i}`,
-    file: 'tests/wide.rs',
-  }));
-  const out = formatCoveringTests(many, 'src/hot.rs');
-  assert.match(out, new RegExp(`Covering tests: ${LIST_CAP + 1}`));
-  assert.match(out, /widely-tested/);
-  assert.match(out, /Run the suite after editing: cargo test/);
-  // The long per-name list must NOT be inlined when fan-out is high.
-  assert.doesNotMatch(out, /test_0 \(/);
-});
-
-test('covering: non-Rust high fan-out collapses to a count with no command', () => {
-  const many = Array.from({ length: LIST_CAP + 3 }, (_, i) => ({
-    name: `test_${i}`,
-    file: 'a.test.ts',
-  }));
-  const out = formatCoveringTests(many, 'src/hot.ts');
-  assert.match(out, new RegExp(`Covering tests: ${LIST_CAP + 3}`));
-  assert.doesNotMatch(out, /cargo test/);
-});

package/claude-plugin/scripts/doctor.test.js

@@ -1,215 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { runDiagnostics, formatReport, surveyHookCoverage } = require('./doctor');
-const { buildSettingsHookEntries } = require('./lifecycle');
-
-// Build a settings.json whose hooks exactly mirror what we'd register now.
-function settingsWithCurrentHooks() {
-  const desired = buildSettingsHookEntries();
-  const hooks = {};
-  for (const [event, entries] of Object.entries(desired)) {
-    hooks[event] = entries.map(e => JSON.parse(JSON.stringify(e)));
-  }
-  return { hooks };
-}
-
-test('runDiagnostics returns an array of check results', () => {
-  const results = runDiagnostics();
-  assert.ok(Array.isArray(results));
-  assert.ok(results.length > 0, 'should have at least one check result');
-  for (const r of results) {
-    assert.equal(typeof r.name, 'string');
-    assert.ok(['ok', 'warn', 'error', 'skip'].includes(r.status));
-    assert.equal(typeof r.detail, 'string');
-  }
-});
-
-test('formatReport produces readable output', () => {
-  const results = [
-    { name: 'Binary version', status: 'ok', detail: 'v0.7.16' },
-    { name: 'Source fresh', status: 'warn', detail: 'src/ modified 3min after binary', fixId: 'binary-stale' },
-    { name: 'Schema', status: 'ok', detail: 'v6' },
-  ];
-  const output = formatReport(results);
-  assert.ok(output.includes('Binary version'));
-  assert.ok(output.includes('v0.7.16'));
-  assert.ok(output.includes('Source fresh'));
-  assert.ok(output.includes('3min'));
-});
-
-test('formatReport shows issue count when problems exist', () => {
-  const results = [
-    { name: 'Test', status: 'warn', detail: 'problem', fixId: 'test-fix' },
-  ];
-  const output = formatReport(results);
-  assert.ok(output.includes('1'));
-  assert.ok(output.includes('issue'));
-});
-
-test('formatReport: --check-only never says "Fixing..." (it does not repair)', () => {
-  const results = [
-    { name: 'Hook coverage', status: 'warn', detail: 'missing', fixId: 'hooks' },
-  ];
-  // Default (repair mode) announces the fix.
-  assert.ok(formatReport(results).includes('Fixing...'),
-    'repair mode should announce Fixing...');
-  // --check-only is read-only: it must NOT claim to fix, and should point the
-  // user at the repair command instead.
-  const checkOnly = formatReport(results, { checkOnly: true });
-  assert.ok(!checkOnly.includes('Fixing...'),
-    `--check-only must not say "Fixing..."; got: ${checkOnly}`);
-  assert.ok(checkOnly.includes('--check-only'),
-    `--check-only should hint how to fix; got: ${checkOnly}`);
-});
-
-test('formatReport shows all-clear when no problems', () => {
-  const results = [
-    { name: 'Binary version', status: 'ok', detail: 'v0.7.16' },
-    { name: 'Schema', status: 'ok', detail: 'v6' },
-  ];
-  const output = formatReport(results);
-  assert.ok(output.includes('All checks passed') || output.includes('0 issues'));
-});
-
-test('surveyHookCoverage reports clean when all entries are current', () => {
-  const cov = surveyHookCoverage(settingsWithCurrentHooks());
-  assert.equal(cov.missing.length, 0, 'no missing entries');
-  assert.equal(cov.stale.length, 0, 'no stale entries');
-});
-
-test('surveyHookCoverage flags a present-but-stale hook path', () => {
-  const settings = settingsWithCurrentHooks();
-  // Repoint one PreToolUse entry at an old plugin-cache version dir — present,
-  // recognized as ours (description unchanged), but command no longer current.
-  const bash = settings.hooks.PreToolUse.find(e => e.matcher === 'Bash');
-  bash.hooks[0].command = bash.hooks[0].command.replace('/scripts/', '/0.0.1-old/scripts/');
-  const cov = surveyHookCoverage(settings);
-  assert.equal(cov.missing.length, 0, 'entry is present, not missing');
-  assert.ok(cov.stale.includes('PreToolUse:Bash'),
-    `stale Bash path should be flagged; got stale=${JSON.stringify(cov.stale)}`);
-});
-
-test('surveyHookCoverage flags missing entries when settings empty', () => {
-  const cov = surveyHookCoverage({});
-  assert.ok(cov.missing.length === cov.expected.length, 'all expected entries missing');
-  assert.equal(cov.stale.length, 0, 'nothing present to be stale');
-});
-
-// ── relicRepairGuard (v0.50.0 — doctor twin of the session-init relic guard) ──
-
-test('relicRepairGuard blocks settings repair from a relic copy and redirects', () => {
-  const { relicRepairGuard } = require('./doctor');
-  const lines = [];
-  // Relic context → guard fires, prints the redirect, returns true (skip install).
-  assert.equal(relicRepairGuard({ relic: true, log: (s) => lines.push(s) }), true);
-  assert.ok(lines.some(l => l.includes('not the active install')),
-    `guard must explain why repair is skipped, got: ${lines.join(' | ')}`);
-  // Active (or dev/npm) context → repair proceeds.
-  assert.equal(relicRepairGuard({ relic: false, log: () => {} }), false);
-});
-
-// ── classifyEmbeddings (vector-availability — warns on silent FTS5-only) ──
-
-test('classifyEmbeddings WARNS when embed-capable but nothing embedded (vector inactive)', () => {
-  const { classifyEmbeddings } = require('./doctor');
-  // The exact silent-FTS5 gap: model_available compile-flag true, real embeddable
-  // nodes exist, but 0 embedded (model never downloaded/loaded).
-  const r = classifyEmbeddings({ model_available: true, embedding_progress: '0/2745',
-    embedding_status: 'pending', search_mode: 'fts_only' });
-  assert.equal(r.status, 'warn', 'must not false-green a vector-inactive index');
-  assert.match(r.detail, /FTS5-only|vector INACTIVE/);
-});
-
-test('classifyEmbeddings WARNS when binary lacks embed-model feature', () => {
-  const { classifyEmbeddings } = require('./doctor');
-  const r = classifyEmbeddings({ model_available: false, embedding_progress: '0/0' });
-  assert.equal(r.status, 'warn');
-  assert.match(r.detail, /without embed-model/);
-});
-
-test('classifyEmbeddings OK for hybrid (partial + complete) and no-embeddable', () => {
-  const { classifyEmbeddings } = require('./doctor');
-  assert.equal(classifyEmbeddings({ model_available: true, embedding_progress: '900/2745' }).status, 'ok');
-  assert.equal(classifyEmbeddings({ model_available: true, embedding_progress: '2745/2745' }).status, 'ok');
-  // total === 0 is a non-code index, genuinely nothing to embed → ok, not a false warn.
-  const none = classifyEmbeddings({ model_available: true, embedding_progress: '0/0' });
-  assert.equal(none.status, 'ok');
-  assert.match(none.detail, /no embeddable nodes/);
-});
-
-// ── dev-rebuild feature preservation (no silent hybrid→FTS5 downgrade / ping-pong) ──
-test('devBuildCommand preserves feature set: hybrid → --features embed-model, fts → --no-default-features', () => {
-  const { devBuildCommand } = require('./doctor');
-  assert.match(devBuildCommand(true), /--features embed-model/);
-  assert.doesNotMatch(devBuildCommand(true), /--no-default-features/);
-  assert.match(devBuildCommand(false), /--no-default-features/);
-  assert.doesNotMatch(devBuildCommand(false), /--features embed-model/);
-});
-
-test('detectEmbedModel reads model_available from `health-check --json`; probe failure → null (never a false downgrade signal)', () => {
-  const { detectEmbedModel } = require('./doctor');
-  // hybrid binary
-  const hybridStub = (_bin, args) => {
-    assert.deepEqual(args, ['health-check', '--json']);
-    return JSON.stringify({ model_available: true });
-  };
-  assert.equal(detectEmbedModel('/bin/cg', hybridStub), true);
-  // FTS5-only binary
-  assert.equal(detectEmbedModel('/bin/cg', () => JSON.stringify({ model_available: false })), false);
-  // probe throws (binary broken) → null (caller defaults to FTS5 + note, not a downgrade claim)
-  assert.equal(detectEmbedModel('/bin/cg', () => { throw new Error('boom'); }), null);
-  // unparseable output → null
-  assert.equal(detectEmbedModel('/bin/cg', () => 'not json'), null);
-  // no binary → null
-  assert.equal(detectEmbedModel(null), null);
-});
-
-test('unresolvedCount: repair mode exits 0 iff every found issue was fixed', () => {
-  const { unresolvedCount } = require('./doctor');
-  // Clean run — nothing found.
-  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 0, fixed: 0 }), 0);
-  // Repair fixed everything ("N/N addressed") → 0, so `doctor && …` and
-  // self-heal automation don't read a successful repair as failure. This is
-  // the regression this contract guards: previously exited 1 on any issue found.
-  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 3, fixed: 3 }), 0);
-  // Partial repair → the remainder is unresolved (nonzero → exit 1).
-  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 3, fixed: 1 }), 2);
-  // Advisory-only issue with no working auto-repair (fixed stays 0) → unresolved.
-  assert.equal(unresolvedCount({ checkOnly: false, issueCount: 1, fixed: 0 }), 1);
-});
-
-test('unresolvedCount: --check-only reports every found issue (never repairs)', () => {
-  const { unresolvedCount } = require('./doctor');
-  // check-only performs no repair, so fixed is 0; a found issue must still
-  // surface as unresolved (exit 1) — check mode reports cleanliness.
-  assert.equal(unresolvedCount({ checkOnly: true, issueCount: 2, fixed: 0 }), 2);
-  assert.equal(unresolvedCount({ checkOnly: true, issueCount: 0, fixed: 0 }), 0);
-});
-
-test('runRepairs: hooks-invalid counts fixed only when the post-install re-scan is clean', () => {
-  // hooks-invalid is raised only after diagnosis already ran install()+re-scan
-  // and paths were STILL broken. The repair arm must re-verify, else it reports
-  // a false exit 0 ("healthy") while the hooks stay broken. Stub the lifecycle
-  // deps runRepairs pulls via require('./lifecycle') on the shared cached export
-  // object; restore in finally so no other test sees the stubs.
-  const { runRepairs } = require('./doctor');
-  const lc = require('./lifecycle');
-  const orig = { install: lc.install, scan: lc.scanForBrokenPaths, relic: lc.isStaleRelicContext };
-  const hooksInvalid = [{ name: 'Hooks', status: 'warn', fixId: 'hooks-invalid' }];
-  try {
-    lc.isStaleRelicContext = () => false;   // not a relic → repair proceeds
-    lc.install = () => {};                    // install() that cannot restore the paths
-    // Re-scan still broken → must NOT count as fixed (old code did fixed++ blindly).
-    lc.scanForBrokenPaths = () => [{ type: 'hook', event: 'PreToolUse:Edit', path: '/gone.js' }];
-    assert.equal(runRepairs(hooksInvalid), 0, 'still-broken after install must not count as fixed');
-    // Re-scan clean → the repair took effect → counts as fixed.
-    lc.scanForBrokenPaths = () => [];
-    assert.equal(runRepairs(hooksInvalid), 1, 'verified-clean after install counts as fixed');
-  } finally {
-    lc.install = orig.install;
-    lc.scanForBrokenPaths = orig.scan;
-    lc.isStaleRelicContext = orig.relic;
-  }
-});