@monoes/monograph 1.1.0 → 1.2.0

package/src/__tests__/pipeline/phases/scope-resolution.java.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { extractJavaCallSites } from '../../../pipeline/phases/scope-resolution.js';
+
+describe('extractJavaCallSites', () => {
+  it('extracts method calls', () => {
+    const source = `
+public void run() {
+  service.process(request);
+  logger.info("done");
+}`;
+    const sites = extractJavaCallSites(source, '/src/Main.java', 'fn1');
+    expect(sites.some(s => s.calleeRaw === 'service.process')).toBe(true);
+    expect(sites.some(s => s.calleeRaw === 'logger.info')).toBe(true);
+  });
+
+  it('extracts direct function calls', () => {
+    const source = `Objects.requireNonNull(val);`;
+    const sites = extractJavaCallSites(source, '/src/Main.java', 'fn1');
+    expect(sites.length).toBeGreaterThan(0);
+  });
+
+  it('skips Java keywords', () => {
+    const source = `if (x) { for (int i = 0; i < 10; i++) { return; } }`;
+    const sites = extractJavaCallSites(source, '/src/Main.java', 'fn1');
+    const names = sites.map(s => s.calleeRaw);
+    expect(names).not.toContain('if');
+    expect(names).not.toContain('for');
+    expect(names).not.toContain('return');
+  });
+});

package/src/__tests__/pipeline/phases/scope-resolution.rust.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { extractRustCallSites } from '../../../pipeline/phases/scope-resolution.js';
+
+describe('extractRustCallSites', () => {
+  it('extracts method calls', () => {
+    const source = `
+fn main() {
+  server.run();
+  db.connect("sqlite::memory:");
+}`;
+    const sites = extractRustCallSites(source, '/src/main.rs', 'fn1');
+    expect(sites.some(s => s.calleeRaw === 'server.run')).toBe(true);
+    expect(sites.some(s => s.calleeRaw === 'db.connect')).toBe(true);
+  });
+
+  it('extracts direct function calls', () => {
+    const source = `fn setup() { init_logging(); register_handlers(); }`;
+    const sites = extractRustCallSites(source, '/src/main.rs', 'fn1');
+    expect(sites.some(s => s.calleeRaw === 'init_logging')).toBe(true);
+    expect(sites.some(s => s.calleeRaw === 'register_handlers')).toBe(true);
+  });
+
+  it('skips Rust keywords', () => {
+    const source = `if let Some(x) = val { for item in list { return Ok(()); } }`;
+    const sites = extractRustCallSites(source, '/src/main.rs', 'fn1');
+    const names = sites.map(s => s.calleeRaw);
+    expect(names).not.toContain('if');
+    expect(names).not.toContain('for');
+    expect(names).not.toContain('return');
+  });
+});

package/src/__tests__/pipeline/phases/suggest-questions.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { suggestPhase } from '../../../pipeline/phases/suggest.js';
+import type { PipelineContext } from '../../../pipeline/types.js';
+
+function makeCtx(db: Database.Database): PipelineContext {
+  return { repoPath: '/tmp', db, graph: {} as any, options: { ignore: [], codeOnly: false } as any, onProgress: () => {} } as any;
+}
+
+function makeDeps(edges: any[], nodes: any[], memberships = new Map<string, number>()) {
+  return new Map([
+    ['parse', { allEdges: edges, symbolNodes: nodes, parseErrors: [], fileContents: new Map() }],
+    ['cross-file', { resolvedEdges: [], importGraph: new Map() }],
+    ['communities', { memberships }],
+    ['mro', { mroEdges: [] }],
+    ['god-nodes', { godNodes: [] }],
+    ['surprises', { surprises: [] }],
+  ]);
+}
+
+describe('suggestPhase question types', () => {
+  it('generates no_signal question for AMBIGUOUS edges with no evidence', async () => {
+    const db = new Database(':memory:');
+    const edges = [{ id: 'e1', sourceId: 'n1', targetId: 'n2', relation: 'CALLS', confidence: 'AMBIGUOUS', confidenceScore: 0.1 }];
+    const nodes = [
+      { id: 'n1', label: 'Function', name: 'doA', isExported: true, normLabel: 'function' },
+      { id: 'n2', label: 'Function', name: 'doB', isExported: true, normLabel: 'function' },
+    ];
+    const result = await suggestPhase.execute(makeCtx(db), makeDeps(edges, nodes));
+    const types = result.questions.map((q: any) => q.type);
+    expect(types).toContain('no_signal');
+  });
+
+  it('generates thin_community question for community with fewer than 3 members', async () => {
+    const db = new Database(':memory:');
+    const edges: any[] = [];
+    const nodes = [
+      { id: 'n1', label: 'Function', name: 'a', isExported: true, normLabel: 'function' },
+      { id: 'n2', label: 'Function', name: 'b', isExported: true, normLabel: 'function' },
+    ];
+    const memberships = new Map([['n1', 5], ['n2', 5]]);
+    const result = await suggestPhase.execute(makeCtx(db), makeDeps(edges, nodes, memberships));
+    const types = result.questions.map((q: any) => q.type);
+    expect(types).toContain('thin_community');
+  });
+});

package/src/__tests__/pipeline/phases/surprises-scoring.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { surprisesPhase } from '../../../pipeline/phases/surprises.js';
+import type { PipelineContext } from '../../../pipeline/types.js';
+
+function makeCtx(db: Database.Database): PipelineContext {
+  return { repoPath: '/tmp', db, graph: {} as any, options: { ignore: [], codeOnly: false } as any, onProgress: () => {} } as any;
+}
+
+describe('surprises 5-factor scoring', () => {
+  it('cross-filetype edges score higher than same-filetype', async () => {
+    // Labels are uniform (all 'Function') and all in same community so that
+    // crossType and crossCommunity bonuses are equal for both edges.
+    // The only differentiator is file type: e1 crosses CODE→DOCUMENT, e2 stays CODE→CODE.
+    const parseOutput = {
+      allEdges: [
+        { id: 'e1', sourceId: 'n1', targetId: 'n2', relation: 'REFERENCES', confidence: 'INFERRED', confidenceScore: 0.5 },
+        { id: 'e2', sourceId: 'n3', targetId: 'n4', relation: 'REFERENCES', confidence: 'INFERRED', confidenceScore: 0.5 },
+      ],
+      symbolNodes: [
+        { id: 'n1', label: 'Function', name: 'doStuff', filePath: '/src/a.ts', isExported: true, normLabel: 'function' },
+        { id: 'n2', label: 'Function', name: 'readme', filePath: '/docs/README.md', isExported: false, normLabel: 'function' },
+        { id: 'n3', label: 'Function', name: 'doOther', filePath: '/src/b.ts', isExported: true, normLabel: 'function' },
+        { id: 'n4', label: 'Function', name: 'helper', filePath: '/src/c.ts', isExported: true, normLabel: 'function' },
+      ],
+      parseErrors: [], fileContents: new Map(),
+    };
+    const crossFileOutput = { resolvedEdges: [], importGraph: new Map() };
+    // All nodes in same community so crossCommunity bonus is equal (zero) for both edges
+    const communitiesOutput = { memberships: new Map([['n1', 0], ['n2', 0], ['n3', 0], ['n4', 0]]) };
+
+    const db = new Database(':memory:');
+    const deps = new Map<string, any>([
+      ['parse', parseOutput],
+      ['cross-file', crossFileOutput],
+      ['communities', communitiesOutput],
+    ]);
+
+    const result = await surprisesPhase.execute(makeCtx(db), deps);
+    const crossType = result.surprises.find(s => s.edge.id === 'e1');
+    const sameType = result.surprises.find(s => s.edge.id === 'e2');
+    expect(crossType).toBeDefined();
+    expect(sameType).toBeDefined();
+    expect(crossType!.score).toBeGreaterThan(sameType!.score);
+  });
+});

package/src/__tests__/pipeline/phases/variables-phase.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { variablesPhase } from '../../../pipeline/phases/variables-phase.js';
+import type { PipelineContext } from '../../../pipeline/types.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (
+      id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
+      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
+      community_id INTEGER, is_exported INTEGER DEFAULT 0,
+      language TEXT, properties TEXT
+    );
+  `);
+  return db;
+}
+
+function makeCtx(db: Database.Database): PipelineContext {
+  return {
+    repoPath: '/tmp',
+    db,
+    graph: {} as any,
+    options: { ignore: [], codeOnly: false } as any,
+    onProgress: () => {},
+  } as any;
+}
+
+describe('variablesPhase', () => {
+  it('has name "variables" and deps ["parse"]', () => {
+    expect(variablesPhase.name).toBe('variables');
+    expect(variablesPhase.deps).toContain('parse');
+  });
+
+  it('inserts Variable nodes for exported consts', async () => {
+    const db = makeDb();
+    const parseOutput = {
+      allEdges: [],
+      symbolNodes: [],
+      parseErrors: [],
+      fileContents: new Map([
+        ['/tmp/app.ts', 'export const API_URL = "https://example.com";\nconst SECRET = "x";'],
+      ]),
+    };
+    const deps = new Map([['parse', parseOutput]]);
+    await variablesPhase.execute(makeCtx(db), deps);
+    const rows = db.prepare('SELECT name, is_exported FROM nodes WHERE label = ?').all('Variable');
+    const names = (rows as any[]).map((r: any) => r.name);
+    expect(names).toContain('API_URL');
+  });
+
+  it('returns variableCount', async () => {
+    const db = makeDb();
+    const parseOutput = {
+      allEdges: [],
+      symbolNodes: [],
+      parseErrors: [],
+      fileContents: new Map([
+        ['/tmp/b.ts', 'export const X = 1;\nexport const Y = 2;'],
+      ]),
+    };
+    const deps = new Map([['parse', parseOutput]]);
+    const result = await variablesPhase.execute(makeCtx(db), deps);
+    expect((result as any).variableCount).toBeGreaterThanOrEqual(2);
+  });
+
+  it('skips files with no variables gracefully', async () => {
+    const db = makeDb();
+    const parseOutput = {
+      allEdges: [],
+      symbolNodes: [],
+      parseErrors: [],
+      fileContents: new Map([['/tmp/empty.ts', '// no vars here']]),
+    };
+    const deps = new Map([['parse', parseOutput]]);
+    await expect(variablesPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
+  });
+});

package/src/__tests__/pipeline/phases/wildcard-phase.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { wildcardSynthesisPhase } from '../../../pipeline/phases/wildcard-phase.js';
+import type { PipelineContext } from '../../../pipeline/types.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT, name TEXT, norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
+    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id TEXT, relation TEXT, confidence TEXT, confidence_score REAL);
+    INSERT INTO nodes VALUES ('n1', 'Function', 'greet', 'greet', '/mod.ts', 1, 5, null, 1, null, null);
+    INSERT INTO nodes VALUES ('n2', 'File', 'main.ts', 'main.ts', '/main.ts', null, null, null, 0, null, null);
+  `);
+  return db;
+}
+
+function makeCtx(db: Database.Database): PipelineContext {
+  return {
+    repoPath: '/tmp',
+    db,
+    graph: {} as any,
+    options: { ignore: [], codeOnly: false } as any,
+    onProgress: () => {},
+  } as any;
+}
+
+describe('wildcardSynthesisPhase', () => {
+  it('has name "wildcard-synthesis" and deps including "parse" and "cross-file"', () => {
+    expect(wildcardSynthesisPhase.name).toBe('wildcard-synthesis');
+    expect(wildcardSynthesisPhase.deps).toContain('parse');
+    expect(wildcardSynthesisPhase.deps).toContain('cross-file');
+  });
+
+  it('synthesizes IMPORTS edges for wildcard namespace member accesses', async () => {
+    const db = makeDb();
+    const source = `import * as mod from '/mod.ts';\nmod.greet("hello");`;
+    const parseOutput = {
+      allEdges: [],
+      symbolNodes: [
+        { id: 'n1', name: 'greet', label: 'Function', normLabel: 'greet', filePath: '/mod.ts', isExported: true },
+        { id: 'n2', name: 'main.ts', label: 'File', normLabel: 'main.ts', filePath: '/main.ts', isExported: false },
+      ],
+      parseErrors: [],
+      fileContents: new Map([['/main.ts', source]]),
+    };
+    const crossFileOutput = { resolvedEdges: [] };
+    const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
+    const result = await wildcardSynthesisPhase.execute(makeCtx(db), deps);
+    expect((result as any).synthesizedCount).toBeGreaterThanOrEqual(0);
+  });
+
+  it('runs without error when no wildcard imports exist', async () => {
+    const db = makeDb();
+    const parseOutput = {
+      allEdges: [],
+      symbolNodes: [],
+      parseErrors: [],
+      fileContents: new Map([['/main.ts', 'import { greet } from "./mod.js"; greet("hello");']]),
+    };
+    const crossFileOutput = { resolvedEdges: [] };
+    const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
+    await expect(wildcardSynthesisPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
+  });
+});

package/src/__tests__/pipeline/runner.parallel.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { PipelineRunner } from '../../pipeline/runner.js';
+import type { PipelinePhase, PipelineContext } from '../../pipeline/types.js';
+
+function makeCtx(): PipelineContext {
+  return { repoPath: '/tmp', options: { ignore: [], codeOnly: false } } as any;
+}
+
+describe('PipelineRunner parallel execution', () => {
+  it('runs independent phases concurrently', async () => {
+    const startTimes: Record<string, number> = {};
+    const endTimes: Record<string, number> = {};
+
+    function makeDelayPhase(name: string, deps: string[], delayMs: number): PipelinePhase<{ name: string }> {
+      return {
+        name,
+        deps,
+        async execute() {
+          startTimes[name] = Date.now();
+          await new Promise(r => setTimeout(r, delayMs));
+          endTimes[name] = Date.now();
+          return { name };
+        },
+      };
+    }
+
+    // a and b are independent, c depends on both
+    const phases = [
+      makeDelayPhase('a', [], 50),
+      makeDelayPhase('b', [], 50),
+      makeDelayPhase('c', ['a', 'b'], 10),
+    ];
+
+    const runner = new PipelineRunner(phases);
+    const t0 = Date.now();
+    await runner.run(makeCtx());
+    const elapsed = Date.now() - t0;
+
+    // Sequential would take 110ms+; parallel should finish in ~65ms
+    expect(elapsed).toBeLessThan(100);
+  });
+
+  it('respects deps — c starts only after a and b finish', async () => {
+    const endTimes: Record<string, number> = {};
+    let cStartTime = 0;
+
+    const phases: PipelinePhase<unknown>[] = [
+      { name: 'a', deps: [], async execute() { await new Promise(r => setTimeout(r, 30)); endTimes['a'] = Date.now(); return {}; } },
+      { name: 'b', deps: [], async execute() { await new Promise(r => setTimeout(r, 30)); endTimes['b'] = Date.now(); return {}; } },
+      { name: 'c', deps: ['a', 'b'], async execute() { cStartTime = Date.now(); return {}; } },
+    ];
+
+    const runner = new PipelineRunner(phases);
+    await runner.run(makeCtx());
+
+    expect(cStartTime).toBeGreaterThanOrEqual(endTimes['a']!);
+    expect(cStartTime).toBeGreaterThanOrEqual(endTimes['b']!);
+  });
+
+  it('outputs map contains all phase results', async () => {
+    const phases: PipelinePhase<unknown>[] = [
+      { name: 'x', deps: [], async execute() { return { val: 1 }; } },
+      { name: 'y', deps: ['x'], async execute(_ctx, deps) { const x = deps.get('x') as any; return { val: x.val + 1 }; } },
+    ];
+    const runner = new PipelineRunner(phases);
+    const outputs = await runner.run(makeCtx());
+    expect((outputs.get('x') as any).val).toBe(1);
+    expect((outputs.get('y') as any).val).toBe(2);
+  });
+
+  it('throws on cycle detection', () => {
+    const phases: PipelinePhase<unknown>[] = [
+      { name: 'a', deps: ['b'], async execute() { return {}; } },
+      { name: 'b', deps: ['a'], async execute() { return {}; } },
+    ];
+    expect(() => new PipelineRunner(phases)).toThrow();
+  });
+});

package/src/__tests__/reporting/graph-report-confidence.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { generateGraphReport } from '../../reporting/graph-report.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
+      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
+      community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
+    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, target_id TEXT NOT NULL,
+      relation TEXT NOT NULL, confidence TEXT DEFAULT 'EXTRACTED', confidence_score REAL DEFAULT 1.0,
+      properties TEXT);
+  `);
+  db.prepare(`INSERT INTO nodes VALUES ('n1','Function','foo',null,'/a.ts',1,5,null,1,null,null)`).run();
+  db.prepare(`INSERT INTO nodes VALUES ('n2','Function','bar',null,'/b.ts',1,3,null,0,null,null)`).run();
+  db.prepare(`INSERT INTO edges VALUES ('e1','n1','n2','CALLS','EXTRACTED',0.9,null)`).run();
+  db.prepare(`INSERT INTO edges VALUES ('e2','n2','n1','CALLS','INFERRED',0.5,null)`).run();
+  db.prepare(`INSERT INTO edges VALUES ('e3','n1','n2','IMPORTS','AMBIGUOUS',0.3,null)`).run();
+  return db;
+}
+
+describe('generateGraphReport confidence audit', () => {
+  it('includes confidence breakdown percentages', () => {
+    const db = makeDb();
+    const result = generateGraphReport(db, '/tmp');
+    expect(result.markdown).toContain('EXTRACTED');
+    expect(result.markdown).toContain('INFERRED');
+    expect(result.markdown).toContain('AMBIGUOUS');
+  });
+
+  it('includes numeric percentage values', () => {
+    const db = makeDb();
+    const result = generateGraphReport(db, '/tmp');
+    expect(result.markdown).toMatch(/\d+\.\d+%|\d+%/);
+  });
+
+  it('includes confidence audit section heading', () => {
+    const db = makeDb();
+    const result = generateGraphReport(db, '/tmp');
+    expect(result.markdown).toContain('Confidence');
+  });
+});

package/src/__tests__/reporting/graph-report-gaps.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { generateGraphReport } from '../../reporting/graph-report.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
+      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
+      community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
+    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, target_id TEXT NOT NULL,
+      relation TEXT NOT NULL, confidence TEXT DEFAULT 'EXTRACTED', confidence_score REAL DEFAULT 1.0, properties TEXT);
+  `);
+  // 2 isolated nodes (no edges)
+  db.prepare(`INSERT INTO nodes VALUES ('iso1','Function','orphan1',null,'/a.ts',1,5,99,1,null,null)`).run();
+  db.prepare(`INSERT INTO nodes VALUES ('iso2','Function','orphan2',null,'/b.ts',1,3,99,1,null,null)`).run();
+  // thin community: only 1 node
+  db.prepare(`INSERT INTO nodes VALUES ('thin1','Function','alone',null,'/c.ts',1,3,7,1,null,null)`).run();
+  // normal connected nodes
+  db.prepare(`INSERT INTO nodes VALUES ('n1','Function','foo',null,'/d.ts',1,5,1,1,null,null)`).run();
+  db.prepare(`INSERT INTO nodes VALUES ('n2','Function','bar',null,'/e.ts',1,3,1,1,null,null)`).run();
+  db.prepare(`INSERT INTO edges VALUES ('e1','n1','n2','CALLS','AMBIGUOUS',0.1,null)`).run();
+  return db;
+}
+
+describe('graph report knowledge gap section', () => {
+  it('includes knowledge gap heading', () => {
+    const r = generateGraphReport(makeDb(), '/tmp');
+    expect(r.markdown).toMatch(/knowledge.gap|Knowledge Gap/i);
+  });
+
+  it('reports isolated nodes', () => {
+    const r = generateGraphReport(makeDb(), '/tmp');
+    expect(r.markdown).toMatch(/isolated|orphan/i);
+  });
+
+  it('reports thin communities', () => {
+    const r = generateGraphReport(makeDb(), '/tmp');
+    expect(r.markdown).toMatch(/thin|small.*communit/i);
+  });
+});

package/src/__tests__/scope-resolution/evidence-weights.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { EvidenceWeights, typeBindingWeightAtDepth } from '../../scope-resolution/evidence-weights.js';
+
+describe('EvidenceWeights', () => {
+  it('local weight is highest origin weight', () => {
+    expect(EvidenceWeights.local).toBeGreaterThan(EvidenceWeights.import);
+    expect(EvidenceWeights.local).toBeGreaterThan(EvidenceWeights.wildcard);
+  });
+
+  it('import weight is higher than wildcard weight', () => {
+    expect(EvidenceWeights.import).toBeGreaterThan(EvidenceWeights.wildcard);
+  });
+
+  it('arity-incompatible is negative', () => {
+    expect(EvidenceWeights.arityMatchIncompatible).toBeLessThan(0);
+  });
+
+  it('unlinkedImportMultiplier is less than 1', () => {
+    expect(EvidenceWeights.unlinkedImportMultiplier).toBeGreaterThan(0);
+    expect(EvidenceWeights.unlinkedImportMultiplier).toBeLessThan(1);
+  });
+
+  it('scopeChainPerDepth is negative', () => {
+    expect(EvidenceWeights.scopeChainPerDepth).toBeLessThan(0);
+  });
+
+  it('has typeBindingByMroDepth as a non-empty array', () => {
+    expect(EvidenceWeights.typeBindingByMroDepth.length).toBeGreaterThan(0);
+  });
+});
+
+describe('typeBindingWeightAtDepth', () => {
+  it('returns first element at depth 0', () => {
+    expect(typeBindingWeightAtDepth(0)).toBe(EvidenceWeights.typeBindingByMroDepth[0]);
+  });
+
+  it('returns last element for depth beyond table length', () => {
+    const last = EvidenceWeights.typeBindingByMroDepth[EvidenceWeights.typeBindingByMroDepth.length - 1];
+    expect(typeBindingWeightAtDepth(100)).toBe(last);
+  });
+
+  it('returns first element for negative depth', () => {
+    expect(typeBindingWeightAtDepth(-1)).toBe(EvidenceWeights.typeBindingByMroDepth[0]);
+  });
+
+  it('decays with depth — depth 1 < depth 0', () => {
+    expect(typeBindingWeightAtDepth(1)).toBeLessThan(typeBindingWeightAtDepth(0));
+  });
+});

package/src/__tests__/search/diacritic.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { stripDiacritics, normalizeSearchTerm } from '../../search/diacritic.js';
+
+describe('stripDiacritics', () => {
+  it('removes accents from French', () => {
+    expect(stripDiacritics('résumé')).toBe('resume');
+  });
+  it('removes umlauts', () => {
+    expect(stripDiacritics('über')).toBe('uber');
+  });
+  it('leaves ASCII unchanged', () => {
+    expect(stripDiacritics('hello world')).toBe('hello world');
+  });
+  it('handles empty string', () => {
+    expect(stripDiacritics('')).toBe('');
+  });
+  it('normalizeSearchTerm lowercases and strips', () => {
+    expect(normalizeSearchTerm('Résumé')).toBe('resume');
+  });
+  it('normalizeSearchTerm trims whitespace', () => {
+    expect(normalizeSearchTerm('  foo  ')).toBe('foo');
+  });
+});

package/src/__tests__/search/embed-stale.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { upsertEmbedding, getEmbeddingContentHash, isEmbeddingStale } from '../../storage/embedding-store.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS embeddings (
+      node_id TEXT PRIMARY KEY,
+      vector BLOB NOT NULL,
+      content_hash TEXT,
+      created_at INTEGER DEFAULT (unixepoch())
+    );
+  `);
+  return db;
+}
+
+describe('embedding stale detection', () => {
+  it('stores content hash with embedding', () => {
+    const db = makeDb();
+    upsertEmbedding(db, 'n1', new Float32Array([0.1, 0.2]), 'hash_abc');
+    const stored = getEmbeddingContentHash(db, 'n1');
+    expect(stored).toBe('hash_abc');
+  });
+
+  it('isEmbeddingStale returns true when hash differs', () => {
+    const db = makeDb();
+    upsertEmbedding(db, 'n1', new Float32Array([0.1, 0.2]), 'old_hash');
+    expect(isEmbeddingStale(db, 'n1', 'new_hash')).toBe(true);
+  });
+
+  it('isEmbeddingStale returns false when hash matches', () => {
+    const db = makeDb();
+    upsertEmbedding(db, 'n1', new Float32Array([0.1, 0.2]), 'same_hash');
+    expect(isEmbeddingStale(db, 'n1', 'same_hash')).toBe(false);
+  });
+
+  it('isEmbeddingStale returns true when no embedding exists', () => {
+    const db = makeDb();
+    expect(isEmbeddingStale(db, 'n1', 'any_hash')).toBe(true);
+  });
+});

package/src/__tests__/search/exact-search.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { exactVectorSearch } from '../../search/exact-search.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
+      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
+      community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
+    CREATE TABLE embeddings (node_id TEXT PRIMARY KEY, vector BLOB NOT NULL, content_hash TEXT, created_at INTEGER);
+  `);
+  db.prepare(`INSERT INTO nodes VALUES ('n1','Function','doAuth',null,'/auth.ts',1,5,null,1,null,null)`).run();
+  db.prepare(`INSERT INTO nodes VALUES ('n2','Function','renderUI',null,'/ui.ts',1,3,null,1,null,null)`).run();
+
+  // Store simple 3-dim embeddings: n1 ~ [1, 0, 0], n2 ~ [0, 1, 0]
+  const v1 = new Float32Array([1, 0, 0]);
+  const v2 = new Float32Array([0, 1, 0]);
+  db.prepare(`INSERT INTO embeddings VALUES ('n1', ?, null, 0)`).run(Buffer.from(v1.buffer));
+  db.prepare(`INSERT INTO embeddings VALUES ('n2', ?, null, 0)`).run(Buffer.from(v2.buffer));
+  return db;
+}
+
+describe('exactVectorSearch', () => {
+  it('returns closest node to query vector', () => {
+    const db = makeDb();
+    const query = new Float32Array([0.9, 0.1, 0]);
+    const results = exactVectorSearch(db, query, { limit: 2 });
+    expect(results[0]?.id).toBe('n1');
+  });
+
+  it('respects limit', () => {
+    const db = makeDb();
+    const query = new Float32Array([1, 0, 0]);
+    const results = exactVectorSearch(db, query, { limit: 1 });
+    expect(results).toHaveLength(1);
+  });
+
+  it('returns score between 0 and 1', () => {
+    const db = makeDb();
+    const query = new Float32Array([1, 0, 0]);
+    const results = exactVectorSearch(db, query, { limit: 2 });
+    expect(results[0]!.score).toBeGreaterThan(0);
+    expect(results[0]!.score).toBeLessThanOrEqual(1);
+  });
+
+  it('returns empty array when no embeddings', () => {
+    const db = new Database(':memory:');
+    db.exec(`CREATE TABLE embeddings (node_id TEXT PRIMARY KEY, vector BLOB NOT NULL, content_hash TEXT, created_at INTEGER);
+             CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL, norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);`);
+    const results = exactVectorSearch(db, new Float32Array([1, 0, 0]), { limit: 5 });
+    expect(results).toHaveLength(0);
+  });
+});