code-auditor-mcp 3.1.1 → 3.4.0

package/dist/codeIndexDB.js

@@ -8,6 +8,11 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { discoverFiles, ALL_EXTENSIONS } from './utils/fileDiscovery.js';
 import { ProjectTaskRepository } from './services/ProjectTaskRepository.js';
+import { mineConventions, computeMinerInputHash } from './conventions/conventionMiner.js';
+import { extractChurn } from './churn/churnExtractor.js';
+import { computeHotspots } from './hotspots/hotspotScorer.js';
+import { populateCallGraphCache, getGraphStats as getGs } from './graph/callGraph.js';
+import { populateImportGraphCache } from './graph/importGraph.js';
 import { QueryParser, compileToSQL } from './search/QueryParser.js';
 import { getPersistedStorageRoot, resolvePersistedIndexPath } from './dataPaths.js';
 import { ContextualError, getErrnoCode } from './mcpToolErrors.js';
@@ -203,6 +208,10 @@ export class CodeIndexDB {
     static instance;
     /** Subclasses (e.g. EnhancedCodeIndexDB) need access for extra tables without `as any`. */
     db;
+    /** Public access to raw SQLite handle — used by ledger writes from external surfaces. */
+    get rawDb() {
+        return this.db;
+    }
     dbPath;
     isInitialized = false;
     initializePromise = null;
@@ -215,23 +224,44 @@ export class CodeIndexDB {
     schemaAdapter;
     schemaUsageAdapter;
     tasksAdapter;
+    conventionsAdapter;
+    fileChurnAdapter;
+    functionChurnAdapter;
+    pairHistoryAdapter;
+    hotspotScoresAdapter;
+    graphCacheAdapter;
     taskRepository = null;
     stmts = new Map();
     // ── Schema version ──────────────────────────────────────────────────
-    static SCHEMA_VERSION = 2;
+    static SCHEMA_VERSION = 7;
     constructor(dbPath = ':memory:') {
         this.dbPath = dbPath === ':memory:' ? dbPath : path.resolve(dbPath);
     }
     // ── Singleton ───────────────────────────────────────────────────────
     static getInstance(dbPath) {
         if (!CodeIndexDB.instance) {
-            const resolved = dbPath !== undefined && dbPath !== ''
-                ? path.resolve(dbPath)
-                : resolvePersistedIndexPath();
+            let resolved;
+            if (dbPath !== undefined && dbPath !== '') {
+                resolved = dbPath === ':memory:' ? ':memory:' : path.resolve(dbPath);
+            }
+            else {
+                resolved = resolvePersistedIndexPath();
+            }
             CodeIndexDB.instance = new CodeIndexDB(resolved);
         }
         return CodeIndexDB.instance;
     }
+    /** Reset the singleton — used by tests that need a fresh in-memory instance. */
+    static resetInstance() {
+        if (CodeIndexDB.instance) {
+            try {
+                CodeIndexDB.instance.db.close();
+            }
+            catch { /* ignore */ }
+            CodeIndexDB.instance.isInitialized = false;
+        }
+        CodeIndexDB.instance = null;
+    }
     // ── Lifecycle ───────────────────────────────────────────────────────
     async initialize() {
         if (this.isInitialized)
@@ -305,6 +335,12 @@ export class CodeIndexDB {
         this.schemaAdapter = new SqliteCollectionAdapter(this.db, 'schema_definitions');
         this.schemaUsageAdapter = new SqliteCollectionAdapter(this.db, 'schema_usage');
         this.tasksAdapter = new SqliteCollectionAdapter(this.db, 'project_tasks');
+        this.conventionsAdapter = new SqliteCollectionAdapter(this.db, 'conventions');
+        this.fileChurnAdapter = new SqliteCollectionAdapter(this.db, 'file_churn');
+        this.functionChurnAdapter = new SqliteCollectionAdapter(this.db, 'function_churn');
+        this.pairHistoryAdapter = new SqliteCollectionAdapter(this.db, 'dry_pair_history');
+        this.hotspotScoresAdapter = new SqliteCollectionAdapter(this.db, 'hotspot_scores');
+        this.graphCacheAdapter = new SqliteCollectionAdapter(this.db, 'graph_cache');
         // Init defaults
         const whitelistCount = this.db.prepare('SELECT COUNT(*) as cnt FROM whitelist').get().cnt;
         if (whitelistCount === 0) {
@@ -338,6 +374,183 @@ export class CodeIndexDB {
         CREATE UNIQUE INDEX IF NOT EXISTS idx_functions_name_file_line ON functions(name, file_path, line_number);
       `);
         }
+        // Migration 2 → 3: Style intelligence tables (Spec 10)
+        if (currentVersion < 3) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS style_declarations (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          property        TEXT NOT NULL,
+          raw_value       TEXT NOT NULL,
+          normalized_value TEXT,
+          mechanism       TEXT NOT NULL,
+          file_path       TEXT NOT NULL,
+          line            INTEGER NOT NULL,
+          context         TEXT,
+          variant_context TEXT,
+          token_ref       TEXT,
+          content_hash    TEXT,
+          created_at      TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_style_decls_property   ON style_declarations(property);
+        CREATE INDEX IF NOT EXISTS idx_style_decls_mechanism  ON style_declarations(mechanism);
+        CREATE INDEX IF NOT EXISTS idx_style_decls_file_path  ON style_declarations(file_path);
+        CREATE INDEX IF NOT EXISTS idx_style_decls_token_ref  ON style_declarations(token_ref);
+        CREATE INDEX IF NOT EXISTS idx_style_decls_content_hash ON style_declarations(content_hash);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS style_declarations_fts USING fts5(
+          property, raw_value, normalized_value,
+          content='style_declarations', content_rowid='id',
+          tokenize='porter unicode61'
+        );
+
+        CREATE TABLE IF NOT EXISTS style_tokens (
+          id         INTEGER PRIMARY KEY AUTOINCREMENT,
+          name       TEXT NOT NULL,
+          value      TEXT NOT NULL,
+          file_path  TEXT NOT NULL,
+          mechanism  TEXT NOT NULL,
+          created_at TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_style_tokens_name ON style_tokens(name);
+
+        CREATE TABLE IF NOT EXISTS style_class_usage (
+          id           INTEGER PRIMARY KEY AUTOINCREMENT,
+          class_name   TEXT NOT NULL,
+          file_path    TEXT NOT NULL,
+          line         INTEGER NOT NULL,
+          mechanism    TEXT NOT NULL,
+          unresolvable INTEGER DEFAULT 0,
+          created_at   TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_style_class_usage_name   ON style_class_usage(class_name);
+        CREATE INDEX IF NOT EXISTS idx_style_class_usage_file   ON style_class_usage(file_path);
+        CREATE INDEX IF NOT EXISTS idx_style_class_usage_unres  ON style_class_usage(unresolvable);
+      `);
+        }
+        // Migration 3 → 4: Convention mining tables (Spec 12)
+        if (currentVersion < 4) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS conventions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          domain TEXT NOT NULL,
+          rule_id TEXT NOT NULL,
+          antecedent TEXT,
+          consequent TEXT,
+          pattern TEXT,
+          directory TEXT,
+          file_path TEXT,
+          line INTEGER,
+          support INTEGER DEFAULT 0,
+          total_cases INTEGER DEFAULT 0,
+          confidence REAL DEFAULT 0,
+          exemplar_file TEXT,
+          exemplar_line INTEGER,
+          hash TEXT,
+          created_at TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_conv_domain ON conventions(domain);
+        CREATE INDEX IF NOT EXISTS idx_conv_rule_id ON conventions(rule_id);
+        CREATE INDEX IF NOT EXISTS idx_conv_directory ON conventions(directory);
+        CREATE INDEX IF NOT EXISTS idx_conv_hash ON conventions(hash);
+      `);
+        }
+        // Migration 4 → 5: Hotspots & temporal analysis (Spec 13)
+        if (currentVersion < 5) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS file_churn (
+          file_path            TEXT PRIMARY KEY,
+          commit_count         INTEGER NOT NULL DEFAULT 0,
+          lines_added          INTEGER NOT NULL DEFAULT 0,
+          lines_deleted        INTEGER NOT NULL DEFAULT 0,
+          distinct_authors     INTEGER NOT NULL DEFAULT 0,
+          dominant_author      TEXT,
+          dominant_author_share REAL DEFAULT 0,
+          last_touched         TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_file_churn_cc ON file_churn(commit_count);
+
+        CREATE TABLE IF NOT EXISTS function_churn (
+          id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+          function_id          INTEGER REFERENCES functions(id) ON DELETE CASCADE,
+          function_name        TEXT NOT NULL,
+          file_path            TEXT NOT NULL,
+          commit_count         INTEGER NOT NULL DEFAULT 0,
+          distinct_authors     INTEGER NOT NULL DEFAULT 0,
+          dominant_author      TEXT,
+          dominant_author_share REAL DEFAULT 0,
+          renamed              INTEGER DEFAULT 0,
+          confidence           REAL DEFAULT 1.0
+        );
+        CREATE INDEX IF NOT EXISTS idx_func_churn_fid ON function_churn(function_id);
+
+        CREATE TABLE IF NOT EXISTS hotspot_scores (
+          target       TEXT PRIMARY KEY,
+          type         TEXT NOT NULL,
+          score        REAL NOT NULL DEFAULT 0,
+          churn_pct    REAL NOT NULL DEFAULT 0,
+          complexity_pct REAL NOT NULL DEFAULT 0,
+          commit_count INTEGER NOT NULL DEFAULT 0,
+          distinct_authors INTEGER NOT NULL DEFAULT 0,
+          dominant_author TEXT,
+          dominant_author_share REAL DEFAULT 0,
+          bus_factor_risk INTEGER DEFAULT 0,
+          complexity   INTEGER NOT NULL DEFAULT 0,
+          updated_at   TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_hotspot_scores_score ON hotspot_scores(score DESC);
+
+        CREATE TABLE IF NOT EXISTS dry_pair_history (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          pair_fingerprint TEXT NOT NULL,
+          file1           TEXT NOT NULL,
+          symbol1         TEXT,
+          line1           INTEGER NOT NULL,
+          content_hash1   TEXT NOT NULL,
+          file2           TEXT NOT NULL,
+          symbol2         TEXT,
+          line2           INTEGER NOT NULL,
+          content_hash2   TEXT NOT NULL,
+          similarity      REAL NOT NULL,
+          timestamp       TEXT DEFAULT (datetime('now')),
+          run_id          TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_dph_fingerprint ON dry_pair_history(pair_fingerprint);
+        CREATE INDEX IF NOT EXISTS idx_dph_run ON dry_pair_history(run_id);
+      `);
+        }
+        // Migration 5 → 6: Graph cache for call/import graph construction (Spec 14)
+        if (currentVersion < 6) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS graph_cache (
+          graph_type   TEXT NOT NULL,
+          node_key     TEXT NOT NULL,
+          neighbor_key TEXT NOT NULL,
+          weight       REAL NOT NULL,
+          PRIMARY KEY (graph_type, node_key, neighbor_key)
+        );
+        CREATE INDEX IF NOT EXISTS idx_gc_type_node ON graph_cache(graph_type, node_key);
+        CREATE INDEX IF NOT EXISTS idx_gc_type_neighbor ON graph_cache(graph_type, neighbor_key);
+      `);
+        }
+        // Migration 6 → 7: Coverage data for cross-domain analysis (Spec 15)
+        if (currentVersion < 7) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS coverage_data (
+          id            INTEGER PRIMARY KEY AUTOINCREMENT,
+          function_name TEXT NOT NULL,
+          file_path     TEXT NOT NULL,
+          line_number   INTEGER,
+          basis         TEXT NOT NULL DEFAULT 'static-reach',
+          covered       INTEGER NOT NULL DEFAULT 0,
+          source        TEXT,
+          imported_at   TEXT DEFAULT (datetime('now')),
+          UNIQUE(function_name, file_path, line_number)
+        );
+        CREATE INDEX IF NOT EXISTS idx_cov_basis ON coverage_data(basis);
+        CREATE INDEX IF NOT EXISTS idx_cov_covered ON coverage_data(covered);
+        CREATE INDEX IF NOT EXISTS idx_cov_function ON coverage_data(function_name);
+      `);
+        }
     }
     // ── SQLite schema ───────────────────────────────────────────────────
     createSchema() {
@@ -508,6 +721,21 @@ export class CodeIndexDB {
       CREATE INDEX IF NOT EXISTS idx_schema_usage_file ON schema_usage(file_path);
       CREATE INDEX IF NOT EXISTS idx_schema_usage_function ON schema_usage(function_name);
 
+      CREATE TABLE IF NOT EXISTS coverage_data (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        function_name TEXT NOT NULL,
+        file_path     TEXT NOT NULL,
+        line_number   INTEGER,
+        basis         TEXT NOT NULL DEFAULT 'static-reach',
+        covered       INTEGER NOT NULL DEFAULT 0,
+        source        TEXT,
+        imported_at   TEXT DEFAULT (datetime('now')),
+        UNIQUE(function_name, file_path, line_number)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cov_basis ON coverage_data(basis);
+      CREATE INDEX IF NOT EXISTS idx_cov_covered ON coverage_data(covered);
+      CREATE INDEX IF NOT EXISTS idx_cov_function ON coverage_data(function_name);
+
       CREATE TABLE IF NOT EXISTS project_tasks (
         taskId         TEXT PRIMARY KEY,
         projectPath    TEXT NOT NULL,
@@ -534,6 +762,174 @@ export class CodeIndexDB {
       CREATE INDEX IF NOT EXISTS idx_project_tasks_source ON project_tasks(source);
       CREATE INDEX IF NOT EXISTS idx_project_tasks_fingerprint ON project_tasks(fingerprint);
       CREATE INDEX IF NOT EXISTS idx_project_tasks_sort ON project_tasks(sortOrder);
+
+      -- Spec 11 R1 — Findings Ledger: append-only audit history
+      CREATE TABLE IF NOT EXISTS findings_ledger_runs (
+        run_id       TEXT PRIMARY KEY,
+        timestamp    TEXT NOT NULL,
+        git_sha      TEXT,
+        git_dirty    INTEGER NOT NULL DEFAULT 0,
+        tool_version TEXT NOT NULL,
+        command      TEXT NOT NULL,
+        surface      TEXT NOT NULL,
+        scope        TEXT NOT NULL,
+        target       TEXT NOT NULL,
+        duration_ms  INTEGER NOT NULL DEFAULT 0,
+        exit_status  INTEGER NOT NULL DEFAULT 0,
+        metadata_json TEXT DEFAULT '{}'
+      );
+      CREATE TABLE IF NOT EXISTS findings_ledger_findings (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id       TEXT NOT NULL REFERENCES findings_ledger_runs(run_id) ON DELETE CASCADE,
+        analyzer     TEXT NOT NULL,
+        rule         TEXT NOT NULL,
+        severity     TEXT NOT NULL,
+        message      TEXT NOT NULL,
+        file         TEXT NOT NULL,
+        line         INTEGER,
+        symbol       TEXT DEFAULT '',
+        fingerprint  TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_ledger_runs_surface    ON findings_ledger_runs(surface);
+      CREATE INDEX IF NOT EXISTS idx_ledger_runs_timestamp   ON findings_ledger_runs(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_ledger_findings_run     ON findings_ledger_findings(run_id);
+      CREATE INDEX IF NOT EXISTS idx_ledger_findings_fp      ON findings_ledger_findings(fingerprint);
+      CREATE INDEX IF NOT EXISTS idx_ledger_findings_rule    ON findings_ledger_findings(analyzer, rule);
+
+      -- Spec 10: Style intelligence tables
+      CREATE TABLE IF NOT EXISTS style_declarations (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        property        TEXT NOT NULL,
+        raw_value       TEXT NOT NULL,
+        normalized_value TEXT,
+        mechanism       TEXT NOT NULL,
+        file_path       TEXT NOT NULL,
+        line            INTEGER NOT NULL,
+        context         TEXT,
+        variant_context TEXT,
+        token_ref       TEXT,
+        content_hash    TEXT,
+        created_at      TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_style_decls_property   ON style_declarations(property);
+      CREATE INDEX IF NOT EXISTS idx_style_decls_mechanism  ON style_declarations(mechanism);
+      CREATE INDEX IF NOT EXISTS idx_style_decls_file_path  ON style_declarations(file_path);
+      CREATE INDEX IF NOT EXISTS idx_style_decls_token_ref  ON style_declarations(token_ref);
+      CREATE INDEX IF NOT EXISTS idx_style_decls_content_hash ON style_declarations(content_hash);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS style_declarations_fts USING fts5(
+        property, raw_value, normalized_value,
+        content='style_declarations', content_rowid='id',
+        tokenize='porter unicode61'
+      );
+
+      CREATE TABLE IF NOT EXISTS style_tokens (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        name       TEXT NOT NULL,
+        value      TEXT NOT NULL,
+        file_path  TEXT NOT NULL,
+        mechanism  TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_style_tokens_name ON style_tokens(name);
+
+      CREATE TABLE IF NOT EXISTS style_class_usage (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        class_name   TEXT NOT NULL,
+        file_path    TEXT NOT NULL,
+        line         INTEGER NOT NULL,
+        mechanism    TEXT NOT NULL,
+        unresolvable INTEGER DEFAULT 0,
+        created_at   TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_style_class_usage_name   ON style_class_usage(class_name);
+      CREATE INDEX IF NOT EXISTS idx_style_class_usage_file   ON style_class_usage(file_path);
+      CREATE INDEX IF NOT EXISTS idx_style_class_usage_unres  ON style_class_usage(unresolvable);
+
+      -- Spec 12: Convention mining
+      CREATE TABLE IF NOT EXISTS conventions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        domain TEXT NOT NULL,
+        rule_id TEXT NOT NULL,
+        antecedent TEXT,
+        consequent TEXT,
+        pattern TEXT,
+        directory TEXT,
+        file_path TEXT,
+        line INTEGER,
+        support INTEGER DEFAULT 0,
+        total_cases INTEGER DEFAULT 0,
+        confidence REAL DEFAULT 0,
+        exemplar_file TEXT,
+        exemplar_line INTEGER,
+        hash TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_conv_domain ON conventions(domain);
+      CREATE INDEX IF NOT EXISTS idx_conv_rule_id ON conventions(rule_id);
+      CREATE INDEX IF NOT EXISTS idx_conv_directory ON conventions(directory);
+      CREATE INDEX IF NOT EXISTS idx_conv_hash ON conventions(hash);
+
+      -- Spec 13: Hotspots & temporal analysis
+      CREATE TABLE IF NOT EXISTS file_churn (
+        file_path            TEXT PRIMARY KEY,
+        commit_count         INTEGER NOT NULL DEFAULT 0,
+        lines_added          INTEGER NOT NULL DEFAULT 0,
+        lines_deleted        INTEGER NOT NULL DEFAULT 0,
+        distinct_authors     INTEGER NOT NULL DEFAULT 0,
+        dominant_author      TEXT,
+        dominant_author_share REAL DEFAULT 0,
+        last_touched         TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_file_churn_cc ON file_churn(commit_count);
+
+      CREATE TABLE IF NOT EXISTS function_churn (
+        id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+        function_id          INTEGER REFERENCES functions(id) ON DELETE CASCADE,
+        function_name        TEXT NOT NULL,
+        file_path            TEXT NOT NULL,
+        commit_count         INTEGER NOT NULL DEFAULT 0,
+        distinct_authors     INTEGER NOT NULL DEFAULT 0,
+        dominant_author      TEXT,
+        dominant_author_share REAL DEFAULT 0,
+        renamed              INTEGER DEFAULT 0,
+        confidence           REAL DEFAULT 1.0
+      );
+      CREATE INDEX IF NOT EXISTS idx_func_churn_fid ON function_churn(function_id);
+
+      CREATE TABLE IF NOT EXISTS hotspot_scores (
+        target       TEXT PRIMARY KEY,
+        type         TEXT NOT NULL,
+        score        REAL NOT NULL DEFAULT 0,
+        churn_pct    REAL NOT NULL DEFAULT 0,
+        complexity_pct REAL NOT NULL DEFAULT 0,
+        commit_count INTEGER NOT NULL DEFAULT 0,
+        distinct_authors INTEGER NOT NULL DEFAULT 0,
+        dominant_author TEXT,
+        dominant_author_share REAL DEFAULT 0,
+        bus_factor_risk INTEGER DEFAULT 0,
+        complexity   INTEGER NOT NULL DEFAULT 0,
+        updated_at   TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_hotspot_scores_score ON hotspot_scores(score DESC);
+
+      CREATE TABLE IF NOT EXISTS dry_pair_history (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        pair_fingerprint TEXT NOT NULL,
+        file1           TEXT NOT NULL,
+        symbol1         TEXT,
+        line1           INTEGER NOT NULL,
+        content_hash1   TEXT NOT NULL,
+        file2           TEXT NOT NULL,
+        symbol2         TEXT,
+        line2           INTEGER NOT NULL,
+        content_hash2   TEXT NOT NULL,
+        similarity      REAL NOT NULL,
+        timestamp       TEXT DEFAULT (datetime('now')),
+        run_id          TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_dph_fingerprint ON dry_pair_history(pair_fingerprint);
+      CREATE INDEX IF NOT EXISTS idx_dph_run ON dry_pair_history(run_id);
     `);
         // Run schema migrations
         this.runMigrations();
@@ -1222,6 +1618,11 @@ export class CodeIndexDB {
             lastUpdated: new Date()
         };
     }
+    /** Get graph statistics — delegates to graph/callGraph.ts (Spec 14 R1). */
+    getGraphStats() {
+        this.ensureInitialized();
+        return getGs(this.db);
+    }
     // ── Lifecycle: clear & close ────────────────────────────────────────
     async clearIndex() {
         this.ensureInitialized();
@@ -1232,7 +1633,13 @@ export class CodeIndexDB {
             this.db.prepare('DELETE FROM code_maps').run();
             this.db.prepare('DELETE FROM schema_definitions').run();
             this.db.prepare('DELETE FROM schema_usage').run();
-            // Preserve: project_tasks, analyzer_configs, whitelist
+            this.db.prepare('DELETE FROM conventions').run();
+            this.db.prepare('DELETE FROM file_churn').run();
+            this.db.prepare('DELETE FROM function_churn').run();
+            this.db.prepare('DELETE FROM hotspot_scores').run();
+            this.db.prepare('DELETE FROM dry_pair_history').run();
+            this.db.prepare('DELETE FROM graph_cache').run();
+            // Preserve: project_tasks, analyzer_configs, whitelist, findings_ledger_runs, findings_ledger_findings
         })();
     }
     async close() {
@@ -1342,6 +1749,72 @@ export class CodeIndexDB {
                 }
             }
         }
+        // Spec 13 — Extract git churn data after index is built and stale entries
+        // are cleaned up. Runs before conventions mining so hotspot data is
+        // available for reordering. Degrades gracefully when no repo exists.
+        if (projectRoot) {
+            try {
+                extractChurn(this.db, projectRoot, { churnWindowMonths: 12 });
+                // Compute hotspot scores from churn data
+                computeHotspots(this.db);
+            }
+            catch {
+                // Churn extraction failure is non-fatal — continue without hotspot data
+            }
+        }
+        // Spec 12 — Mine codebase conventions after sync when the functions table
+        // has changed. Content-hash-based skip: stored hash avoids re-mining.
+        const miningConfig = {
+            minCorpus: 20,
+            pairConfidence: 0.9,
+            modeShare: 0.8,
+            maxConventionsPerDomain: 200,
+        };
+        const newHash = computeMinerInputHash(this.db, miningConfig);
+        const oldHashRow = this.db.prepare("SELECT value FROM meta WHERE key = 'conventions_hash'").get();
+        if (!oldHashRow || oldHashRow.value !== newHash) {
+            const conventions = mineConventions(this.db, miningConfig, projectRoot);
+            // Upsert: clear existing conventions, insert new ones
+            const deleteStmt = this.db.prepare('DELETE FROM conventions');
+            const insertStmt = this.db.prepare(`INSERT INTO conventions
+         (domain, rule_id, antecedent, consequent, pattern, directory,
+          file_path, line, support, total_cases, confidence,
+          exemplar_file, exemplar_line, hash)
+         VALUES (@domain, @rule_id, @antecedent, @consequent, @pattern,
+                 @directory, @file_path, @line, @support, @total_cases,
+                 @confidence, @exemplar_file, @exemplar_line, @hash)`);
+            const upsertAll = this.db.transaction(() => {
+                deleteStmt.run();
+                for (const c of conventions) {
+                    insertStmt.run({
+                        domain: c.domain,
+                        rule_id: c.rule_id,
+                        antecedent: c.antecedent ?? null,
+                        consequent: c.consequent ?? null,
+                        pattern: c.pattern ?? null,
+                        directory: c.directory ?? null,
+                        file_path: c.file_path ?? null,
+                        line: c.line ?? null,
+                        support: c.support,
+                        total_cases: c.total_cases,
+                        confidence: c.confidence,
+                        exemplar_file: c.exemplar_file ?? null,
+                        exemplar_line: c.exemplar_line ?? null,
+                        hash: c.hash ?? null,
+                    });
+                }
+            });
+            upsertAll();
+            this.db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('conventions_hash', ?)").run(newHash);
+        }
+        // Spec 14 — Populate graph caches after index is built
+        try {
+            populateCallGraphCache(this.db);
+            populateImportGraphCache(this.db);
+        }
+        catch {
+            // Graph cache population failure is non-fatal — continue without graph data
+        }
         return {
             syncedFiles,
             addedFunctions: totalAdded,
@@ -1957,6 +2430,15 @@ export class CodeIndexDB {
             this.db.prepare('INSERT INTO schema_usage (schema_id, table_name, file_path, function_name, usage_type, line, "column", raw_query, parameters, recorded_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').run(schemaId ?? 'default', usage.tableName, usage.filePath, usage.functionName, usage.usageType, usage.line ?? null, usage.column ?? null, usage.rawQuery ?? null, JSON.stringify(usage.parameters ?? []), new Date().toISOString());
         }
     }
+    /**
+     * Clear all schema_usage entries for a given file path.
+     * Used for idempotent per-file writes during indexing — stale entries
+     * from a previous scan are removed before fresh references are inserted.
+     */
+    clearSchemaUsageForFile(filePath) {
+        this.ensureInitialized();
+        this.db.prepare('DELETE FROM schema_usage WHERE file_path = ?').run(filePath);
+    }
     async getSchemaUsage(options = {}) {
         this.ensureInitialized();
         const clauses = [];
@@ -2075,6 +2557,180 @@ export class CodeIndexDB {
     async deleteProjectTask(taskId, mode) {
         return this.getTaskRepository().delete(taskId, mode);
     }
+    // ── Meta key-value store ─────────────────────────────────────────────
+    /** Upsert a key-value pair in the meta table. */
+    setMeta(key, value) {
+        this.ensureInitialized();
+        this.db.prepare(`INSERT INTO meta (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(key, value);
+    }
+    /** Retrieve a value from the meta table, or null if absent. */
+    getMeta(key) {
+        this.ensureInitialized();
+        const row = this.db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
+        return row?.value ?? null;
+    }
+    // ── Provenance storage (Spec-21 R2 cross-file) ─────────────────────
+    /** Store per-file provenance context in the meta table. */
+    storeFileProvenance(filePath, provenanceData) {
+        const key = `provenance:${filePath}`;
+        this.setMeta(key, JSON.stringify(provenanceData));
+    }
+    /** Retrieve per-file provenance context, or null if not stored. */
+    getFileProvenance(filePath) {
+        const raw = this.getMeta(`provenance:${filePath}`);
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Store the inferred receiver set as a meta record. */
+    storeInferredReceivers(inferred) {
+        this.setMeta('inferred_receivers', JSON.stringify(inferred));
+    }
+    /** Retrieve the inferred receiver set, or null if not stored. */
+    getInferredReceivers() {
+        const raw = this.getMeta('inferred_receivers');
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Coverage data (Spec 15 R4) ──────────────────────────────────────
+    /** Import coverage entries, replacing any existing data for the given basis. */
+    importCoverageData(entries) {
+        this.ensureInitialized();
+        // Group by basis so we only clear one basis at a time
+        const bases = new Set(entries.map(e => e.basis));
+        const clearStmt = this.db.prepare('DELETE FROM coverage_data WHERE basis = ?');
+        for (const basis of bases) {
+            clearStmt.run(basis);
+        }
+        const insert = this.db.prepare(`INSERT OR REPLACE INTO coverage_data (function_name, file_path, line_number, basis, covered, source, imported_at)
+       VALUES (?, ?, ?, ?, ?, ?, datetime('now'))`);
+        const tx = this.db.transaction((items) => {
+            for (const e of items) {
+                insert.run(e.functionName, e.filePath, e.lineNumber, e.basis, e.covered ? 1 : 0, e.source ?? null);
+            }
+        });
+        tx(entries);
+    }
+    /** Get all coverage entries for a given basis. */
+    getCoverageByBasis(basis) {
+        this.ensureInitialized();
+        const rows = this.db.prepare('SELECT * FROM coverage_data WHERE basis = ?').all(basis);
+        return rows.map((r) => ({
+            functionName: r.function_name,
+            filePath: r.file_path,
+            lineNumber: r.line_number,
+            basis: r.basis,
+            covered: r.covered === 1,
+            source: r.source,
+            importedAt: r.imported_at,
+        }));
+    }
+    /** Clear coverage data, optionally scoped to a single basis. */
+    clearCoverageData(basis) {
+        this.ensureInitialized();
+        if (basis) {
+            this.db.prepare('DELETE FROM coverage_data WHERE basis = ?').run(basis);
+        }
+        else {
+            this.db.prepare('DELETE FROM coverage_data').run();
+        }
+    }
+    /** Check if measured coverage data is stale (older than the last full sync). */
+    isCoverageStale() {
+        this.ensureInitialized();
+        const lastSync = this.getMeta('last_full_sync_timestamp');
+        if (!lastSync)
+            return false;
+        const staleRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM coverage_data
+       WHERE basis = 'measured' AND imported_at < ?`).get(lastSync);
+        return (staleRow?.cnt ?? 0) > 0;
+    }
+    /** Get coverage rate by risk decile for the coverage report. */
+    getCoverageByRiskDecile(decileCount = 10) {
+        this.ensureInitialized();
+        // Rank functions by risk score from hotspot_scores, join with coverage_data
+        const rows = this.db.prepare(`
+      WITH ranked AS (
+        SELECT
+          f.name,
+          f.file_path,
+          f.line_number,
+          COALESCE(hs.score, 0.0) as risk_score,
+          NTILE(?) OVER (ORDER BY COALESCE(hs.score, 0.0) DESC) as decile
+        FROM functions f
+        LEFT JOIN hotspot_scores hs ON hs.target = (f.file_path || ':' || f.name)
+          AND hs.type = 'function'
+        WHERE f.is_exported = 1
+      ),
+      coverage AS (
+        SELECT DISTINCT function_name, file_path FROM coverage_data
+        WHERE covered = 1
+      )
+      SELECT
+        r.decile,
+        COUNT(*) as total,
+        SUM(CASE WHEN c.function_name IS NOT NULL THEN 1 ELSE 0 END) as covered
+      FROM ranked r
+      LEFT JOIN coverage c ON c.function_name = r.name AND c.file_path = r.file_path
+      GROUP BY r.decile
+      ORDER BY r.decile
+    `).all(decileCount);
+        return rows.map((r) => ({
+            decile: r.decile,
+            covered: r.covered,
+            total: r.total,
+            rate: r.total > 0 ? r.covered / r.total : 0,
+        }));
+    }
+    /** Get untested functions in the top risk decile. */
+    getUntestedTopDecile(topDecile = 0.1) {
+        this.ensureInitialized();
+        const rows = this.db.prepare(`
+      WITH ranked AS (
+        SELECT
+          f.name,
+          f.file_path,
+          COALESCE(hs.score, 0.0) as risk_score,
+          PERCENT_RANK() OVER (ORDER BY COALESCE(hs.score, 0.0) DESC) as pct
+        FROM functions f
+        LEFT JOIN hotspot_scores hs ON hs.target = (f.file_path || ':' || f.name)
+          AND hs.type = 'function'
+        WHERE f.is_exported = 1
+      ),
+      best_coverage AS (
+        SELECT DISTINCT function_name, file_path, basis FROM coverage_data
+        WHERE covered = 1
+      )
+      SELECT
+        r.name,
+        r.file_path,
+        r.risk_score,
+        COALESCE(bc.basis, 'static-reach') as basis
+      FROM ranked r
+      LEFT JOIN best_coverage bc ON bc.function_name = r.name AND bc.file_path = r.file_path
+      WHERE r.pct <= ?
+        AND bc.basis IS NULL
+      ORDER BY r.risk_score DESC
+    `).all(topDecile);
+        return rows.map((r) => ({
+            functionName: r.name,
+            filePath: r.file_path,
+            riskScore: r.risk_score,
+            basis: r.basis,
+        }));
+    }
 }
 // ── Helpers ────────────────────────────────────────────────────────────
 function tryParseJson(val) {