@soleri/core 9.0.4 → 9.2.0

package/dist/curator/curator.js

@@ -1,270 +1,80 @@
-import { tokenize, calculateTfIdf, cosineSimilarity, } from '../text/similarity.js';
+import { detectDuplicates as detectDuplicatesPure, DEFAULT_DUPLICATE_THRESHOLD } from './duplicate-detector.js';
+import { findContradictions, DEFAULT_CONTRADICTION_THRESHOLD } from './contradiction-detector.js';
+import { normalizeTag as normalizeTagPure, normalizeAndDedup, addTagAlias as addTagAliasPure, getCanonicalTags as getCanonicalTagsPure, seedDefaultAliases, } from './tag-manager.js';
+import { initializeTables } from './schema.js';
+import { computeHealthAudit } from './health-audit.js';
+import { enrichEntryMetadata } from './metadata-enricher.js';
 // ─── Constants ──────────────────────────────────────────────────────
-const DEFAULT_DUPLICATE_THRESHOLD = 0.45;
-const MERGE_SUGGESTION_THRESHOLD = 0.65;
-const DEFAULT_CONTRADICTION_THRESHOLD = 0.4;
 const DEFAULT_STALE_DAYS = 90;
-const DEFAULT_TAG_ALIASES = [
-    ['a11y', 'accessibility'],
-    ['ts', 'typescript'],
-    ['js', 'javascript'],
-    ['css', 'styling'],
-    ['tailwind', 'styling'],
-    ['tw', 'styling'],
-    ['vitest', 'testing'],
-    ['jest', 'testing'],
-    ['perf', 'performance'],
-    ['sec', 'security'],
-    ['auth', 'authentication'],
-    ['i18n', 'internationalization'],
-    ['l10n', 'localization'],
-];
 // ─── Curator Class ──────────────────────────────────────────────────
 export class Curator {
     vault;
     provider;
+    tagStore;
     constructor(vault) {
         this.vault = vault;
         this.provider = vault.getProvider();
-        this.initializeTables();
-        this.seedDefaultAliases();
+        this.tagStore = this.createTagStore();
+        initializeTables(this.provider);
+        this.provider.transaction(() => seedDefaultAliases(this.tagStore));
     }
-    // ─── Schema ─────────────────────────────────────────────────────
-    initializeTables() {
-        this.provider.execSql(`
-      CREATE TABLE IF NOT EXISTS curator_entry_state (
-        entry_id TEXT PRIMARY KEY,
-        status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'stale', 'archived')),
-        confidence REAL NOT NULL DEFAULT 1.0,
-        source TEXT NOT NULL DEFAULT 'unknown' CHECK(source IN ('manual', 'capture', 'seed', 'unknown')),
-        last_groomed_at INTEGER,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch())
-      );
-
-      CREATE TABLE IF NOT EXISTS curator_tag_canonical (
-        tag TEXT PRIMARY KEY,
-        description TEXT,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch())
-      );
-
-      CREATE TABLE IF NOT EXISTS curator_tag_alias (
-        alias TEXT PRIMARY KEY,
-        canonical TEXT NOT NULL,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-        FOREIGN KEY (canonical) REFERENCES curator_tag_canonical(tag)
-      );
-
-      CREATE TABLE IF NOT EXISTS curator_changelog (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        action TEXT NOT NULL,
-        entry_id TEXT NOT NULL,
-        before_value TEXT,
-        after_value TEXT,
-        reason TEXT NOT NULL,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch())
-      );
-
-      CREATE TABLE IF NOT EXISTS curator_entry_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        entry_id TEXT NOT NULL,
-        snapshot TEXT NOT NULL,
-        changed_by TEXT DEFAULT 'system',
-        change_reason TEXT,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch())
-      );
-
-      CREATE TABLE IF NOT EXISTS curator_contradictions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        pattern_id TEXT NOT NULL,
-        antipattern_id TEXT NOT NULL,
-        similarity REAL NOT NULL,
-        status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open', 'resolved', 'dismissed')),
-        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-        resolved_at INTEGER,
-        UNIQUE(pattern_id, antipattern_id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_curator_state_status ON curator_entry_state(status);
-      CREATE INDEX IF NOT EXISTS idx_curator_changelog_entry ON curator_changelog(entry_id);
-    `);
-    }
-    seedDefaultAliases() {
-        this.provider.transaction(() => {
-            const canonicals = new Set(DEFAULT_TAG_ALIASES.map(([, c]) => c));
-            for (const tag of canonicals) {
-                this.provider.run('INSERT OR IGNORE INTO curator_tag_canonical (tag) VALUES (?)', [tag]);
-            }
-            for (const [alias, canonical] of DEFAULT_TAG_ALIASES) {
-                this.provider.run('INSERT OR IGNORE INTO curator_tag_alias (alias, canonical) VALUES (?, ?)', [alias, canonical]);
-            }
-        });
+    createTagStore() {
+        const p = this.provider;
+        return {
+            getAlias(lower) {
+                return p.get('SELECT canonical FROM curator_tag_alias WHERE alias = ?', [lower])?.canonical ?? null;
+            },
+            insertCanonical(tag) {
+                p.run('INSERT OR IGNORE INTO curator_tag_canonical (tag) VALUES (?)', [tag]);
+            },
+            upsertAlias(alias, canonical) {
+                p.run('INSERT OR REPLACE INTO curator_tag_alias (alias, canonical) VALUES (?, ?)', [alias, canonical]);
+            },
+            getCanonicalRows() {
+                return p.all(`SELECT c.tag, c.description, (SELECT COUNT(*) FROM curator_tag_alias a WHERE a.canonical = c.tag) as alias_count FROM curator_tag_canonical c ORDER BY c.tag`);
+            },
+            countTagUsage(tag) {
+                return p.get('SELECT COUNT(*) as count FROM entries WHERE tags LIKE ?', [`%"${tag}"%`])?.count ?? 0;
+            },
+        };
     }
     // ─── Status ─────────────────────────────────────────────────────
     getStatus() {
-        const tableCount = (table) => (this.provider.get(`SELECT COUNT(*) as count FROM ${table}`) ?? {
-            count: 0,
-        }).count;
+        const tableCount = (table) => (this.provider.get(`SELECT COUNT(*) as count FROM ${table}`) ?? { count: 0 }).count;
         const lastGroomed = this.provider.get('SELECT MAX(last_groomed_at) as ts FROM curator_entry_state WHERE last_groomed_at IS NOT NULL') ?? { ts: null };
         return {
             initialized: true,
-            tables: {
-                entry_state: tableCount('curator_entry_state'),
-                tag_canonical: tableCount('curator_tag_canonical'),
-                tag_alias: tableCount('curator_tag_alias'),
-                changelog: tableCount('curator_changelog'),
-                contradictions: tableCount('curator_contradictions'),
-            },
+            tables: { entry_state: tableCount('curator_entry_state'), tag_canonical: tableCount('curator_tag_canonical'), tag_alias: tableCount('curator_tag_alias'), changelog: tableCount('curator_changelog'), contradictions: tableCount('curator_contradictions') },
             lastGroomedAt: lastGroomed.ts,
         };
     }
-    // ─── Tag Normalization ──────────────────────────────────────────
-    normalizeTag(tag) {
-        const lower = tag.toLowerCase().trim();
-        const row = this.provider.get('SELECT canonical FROM curator_tag_alias WHERE alias = ?', [lower]);
-        if (row) {
-            return { original: tag, normalized: row.canonical, wasAliased: true };
-        }
-        return { original: tag, normalized: lower, wasAliased: false };
-    }
+    // ─── Tags (delegates to tag-manager) ──────────────────────────
+    normalizeTag(tag) { return normalizeTagPure(tag, this.tagStore); }
     normalizeTags(entryId) {
         const entry = this.vault.get(entryId);
         if (!entry)
             return [];
-        const results = [];
-        const normalizedTags = [];
-        let changed = false;
-        for (const tag of entry.tags) {
-            const result = this.normalizeTag(tag);
-            results.push(result);
-            normalizedTags.push(result.normalized);
-            if (result.normalized !== tag)
-                changed = true;
-        }
+        const { results, dedupedTags, changed } = normalizeAndDedup(entry.tags, this.tagStore);
         if (changed) {
-            const dedupedTags = [...new Set(normalizedTags)];
-            this.provider.run('UPDATE entries SET tags = ?, updated_at = unixepoch() WHERE id = ?', [
-                JSON.stringify(dedupedTags),
-                entryId,
-            ]);
+            this.provider.run('UPDATE entries SET tags = ?, updated_at = unixepoch() WHERE id = ?', [JSON.stringify(dedupedTags), entryId]);
             this.logChange('normalize_tags', entryId, JSON.stringify(entry.tags), JSON.stringify(dedupedTags), 'Tag normalization');
         }
         return results;
     }
-    addTagAlias(alias, canonical) {
-        const lower = alias.toLowerCase().trim();
-        const canonicalLower = canonical.toLowerCase().trim();
-        this.provider.run('INSERT OR IGNORE INTO curator_tag_canonical (tag) VALUES (?)', [
-            canonicalLower,
-        ]);
-        this.provider.run('INSERT OR REPLACE INTO curator_tag_alias (alias, canonical) VALUES (?, ?)', [
-            lower,
-            canonicalLower,
-        ]);
-    }
-    getCanonicalTags() {
-        const rows = this.provider.all(`SELECT c.tag, c.description,
-        (SELECT COUNT(*) FROM curator_tag_alias a WHERE a.canonical = c.tag) as alias_count
-      FROM curator_tag_canonical c
-      ORDER BY c.tag`);
-        return rows.map((row) => ({
-            tag: row.tag,
-            description: row.description,
-            usageCount: this.countTagUsage(row.tag),
-            aliasCount: row.alias_count,
-        }));
-    }
-    countTagUsage(tag) {
-        const row = this.provider.get('SELECT COUNT(*) as count FROM entries WHERE tags LIKE ?', [`%"${tag}"%`]);
-        return row?.count ?? 0;
-    }
-    // ─── Duplicate Detection ────────────────────────────────────────
+    addTagAlias(alias, canonical) { addTagAliasPure(alias, canonical, this.tagStore); }
+    getCanonicalTags() { return getCanonicalTagsPure(this.tagStore); }
+    // ─── Duplicates (delegates to duplicate-detector) ─────────────
     detectDuplicates(entryId, threshold) {
-        const effectiveThreshold = threshold ?? DEFAULT_DUPLICATE_THRESHOLD;
-        const entries = this.vault.list({ limit: 100000 });
-        if (entries.length === 0)
-            return [];
-        // Build transient vocabulary
-        const vocabulary = this.buildVocabulary(entries);
-        // Build vectors for all entries
-        const vectors = new Map();
-        for (const entry of entries) {
-            const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
-            vectors.set(entry.id, calculateTfIdf(tokenize(text), vocabulary));
-        }
-        const targetEntries = entryId ? entries.filter((e) => e.id === entryId) : entries;
-        const results = [];
-        for (const entry of targetEntries) {
-            const entryVec = vectors.get(entry.id);
-            const matches = [];
-            for (const other of entries) {
-                if (other.id === entry.id)
-                    continue;
-                const otherVec = vectors.get(other.id);
-                const similarity = cosineSimilarity(entryVec, otherVec);
-                if (similarity >= effectiveThreshold) {
-                    matches.push({
-                        entryId: other.id,
-                        title: other.title,
-                        similarity,
-                        suggestMerge: similarity >= MERGE_SUGGESTION_THRESHOLD,
-                    });
-                }
-            }
-            if (matches.length > 0) {
-                matches.sort((a, b) => b.similarity - a.similarity);
-                results.push({
-                    entryId: entry.id,
-                    matches,
-                    scannedCount: entries.length - 1,
-                });
-            }
-        }
-        return results;
+        return detectDuplicatesPure(this.vault.list({ limit: 100000 }), entryId, threshold);
     }
-    // ─── Contradictions ─────────────────────────────────────────────
+    // ─── Contradictions (delegates to contradiction-detector) ─────
     detectContradictions(threshold) {
-        const effectiveThreshold = threshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
-        const entries = this.vault.list({ limit: 100000 });
-        const antipatterns = entries.filter((e) => e.type === 'anti-pattern');
-        const patterns = entries.filter((e) => e.type === 'pattern');
-        if (antipatterns.length === 0 || patterns.length === 0)
-            return [];
-        const vocabulary = this.buildVocabulary(entries);
-        const detected = [];
-        for (const ap of antipatterns) {
-            // Stage 1: FTS5 candidate retrieval (fall back to all patterns if FTS returns empty)
-            let candidates;
-            try {
-                const searchResults = this.vault.search(ap.title, { type: 'pattern', limit: 20 });
-                candidates = searchResults.length > 0 ? searchResults.map((r) => r.entry) : patterns;
-            }
-            catch {
-                candidates = patterns;
-            }
-            // Stage 2: TF-IDF cosine similarity
-            const apText = [ap.title, ap.description, ap.context ?? ''].join(' ');
-            const apVec = calculateTfIdf(tokenize(apText), vocabulary);
-            for (const pattern of candidates) {
-                const pText = [pattern.title, pattern.description, pattern.context ?? ''].join(' ');
-                const pVec = calculateTfIdf(tokenize(pText), vocabulary);
-                const similarity = cosineSimilarity(apVec, pVec);
-                if (similarity >= effectiveThreshold) {
-                    const result = this.provider.run('INSERT OR IGNORE INTO curator_contradictions (pattern_id, antipattern_id, similarity) VALUES (?, ?, ?)', [pattern.id, ap.id, similarity]);
-                    if (result.changes > 0) {
-                        const row = this.provider.get('SELECT * FROM curator_contradictions WHERE pattern_id = ? AND antipattern_id = ?', [pattern.id, ap.id]);
-                        if (row)
-                            detected.push(this.rowToContradiction(row));
-                    }
-                }
-            }
-        }
-        return detected;
+        const searchFn = (title) => this.vault.search(title, { type: 'pattern', limit: 20 }).map((r) => r.entry);
+        return this.persistContradictions(findContradictions(this.vault.list({ limit: 100000 }), threshold, searchFn));
     }
     getContradictions(status) {
-        const query = status
-            ? 'SELECT * FROM curator_contradictions WHERE status = ? ORDER BY similarity DESC'
-            : 'SELECT * FROM curator_contradictions ORDER BY similarity DESC';
-        const rows = this.provider.all(query, status ? [status] : undefined);
-        return rows.map((r) => this.rowToContradiction(r));
+        const query = status ? 'SELECT * FROM curator_contradictions WHERE status = ? ORDER BY similarity DESC' : 'SELECT * FROM curator_contradictions ORDER BY similarity DESC';
+        return this.provider.all(query, status ? [status] : undefined).map((r) => this.rowToContradiction(r));
     }
     resolveContradiction(id, resolution) {
         this.provider.run('UPDATE curator_contradictions SET status = ?, resolved_at = unixepoch() WHERE id = ?', [resolution, id]);
@@ -272,73 +82,27 @@ export class Curator {
         return row ? this.rowToContradiction(row) : null;
     }
     async detectContradictionsHybrid(threshold) {
-        const effectiveThreshold = threshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
-        const entries = this.vault.list({ limit: 100000 });
-        const antipatterns = entries.filter((e) => e.type === 'anti-pattern');
-        const patterns = entries.filter((e) => e.type === 'pattern');
-        if (antipatterns.length === 0 || patterns.length === 0) {
-            return { contradictions: [], method: 'tfidf-only' };
-        }
-        const vocabulary = this.buildVocabulary(entries);
-        const detected = [];
-        for (const ap of antipatterns) {
-            let candidates;
-            try {
-                const searchResults = this.vault.search(ap.title, { type: 'pattern', limit: 20 });
-                candidates = searchResults.length > 0 ? searchResults.map((r) => r.entry) : patterns;
-            }
-            catch {
-                candidates = patterns;
-            }
-            const apText = [ap.title, ap.description, ap.context ?? ''].join(' ');
-            const apVec = calculateTfIdf(tokenize(apText), vocabulary);
-            for (const pattern of candidates) {
-                const pText = [pattern.title, pattern.description, pattern.context ?? ''].join(' ');
-                const pVec = calculateTfIdf(tokenize(pText), vocabulary);
-                const finalScore = cosineSimilarity(apVec, pVec);
-                if (finalScore >= effectiveThreshold) {
-                    const result = this.provider.run('INSERT OR IGNORE INTO curator_contradictions (pattern_id, antipattern_id, similarity) VALUES (?, ?, ?)', [pattern.id, ap.id, finalScore]);
-                    if (result.changes > 0) {
-                        const row = this.provider.get('SELECT * FROM curator_contradictions WHERE pattern_id = ? AND antipattern_id = ?', [pattern.id, ap.id]);
-                        if (row)
-                            detected.push(this.rowToContradiction(row));
-                    }
-                }
-            }
-        }
-        return {
-            contradictions: detected,
-            method: 'tfidf-only',
-        };
+        const searchFn = (title) => this.vault.search(title, { type: 'pattern', limit: 20 }).map((r) => r.entry);
+        return { contradictions: this.persistContradictions(findContradictions(this.vault.list({ limit: 100000 }), threshold, searchFn)), method: 'tfidf-only' };
     }
-    // ─── Grooming ───────────────────────────────────────────────────
+    // ─── Grooming ─────────────────────────────────────────────────
     groomEntry(entryId) {
         const entry = this.vault.get(entryId);
         if (!entry)
             return null;
         const tagsNormalized = this.normalizeTags(entryId);
-        // Check staleness based on entry's updated_at timestamp
         const row = this.provider.get('SELECT updated_at FROM entries WHERE id = ?', [entryId]);
         const now = Math.floor(Date.now() / 1000);
         const stale = row ? now - row.updated_at > DEFAULT_STALE_DAYS * 86400 : false;
         const status = stale ? 'stale' : 'active';
-        // Upsert entry state
-        this.provider.run(`INSERT INTO curator_entry_state (entry_id, status, last_groomed_at)
-       VALUES (?, ?, unixepoch())
-       ON CONFLICT(entry_id) DO UPDATE SET status = excluded.status, last_groomed_at = unixepoch()`, [entryId, status]);
+        this.provider.run(`INSERT INTO curator_entry_state (entry_id, status, last_groomed_at) VALUES (?, ?, unixepoch()) ON CONFLICT(entry_id) DO UPDATE SET status = excluded.status, last_groomed_at = unixepoch()`, [entryId, status]);
         this.logChange('groom', entryId, null, `status=${status}`, 'Routine grooming');
-        return {
-            entryId,
-            tagsNormalized,
-            stale,
-            lastGroomedAt: now,
-        };
+        return { entryId, tagsNormalized, stale, lastGroomedAt: now };
     }
     groomAll() {
         const start = Date.now();
         const entries = this.vault.list({ limit: 100000 });
-        let tagsNormalized = 0;
-        let staleCount = 0;
+        let tagsNormalized = 0, staleCount = 0;
         for (const entry of entries) {
             const result = this.groomEntry(entry.id);
             if (result) {
@@ -347,41 +111,27 @@ export class Curator {
                     staleCount++;
             }
         }
-        return {
-            totalEntries: entries.length,
-            groomedCount: entries.length,
-            tagsNormalized,
-            staleCount,
-            durationMs: Date.now() - start,
-        };
+        return { totalEntries: entries.length, groomedCount: entries.length, tagsNormalized, staleCount, durationMs: Date.now() - start };
     }
-    // ─── Consolidation ─────────────────────────────────────────────
+    // ─── Consolidation ───────────────────────────────────────────
     consolidate(options) {
         const start = Date.now();
         const dryRun = options?.dryRun ?? true;
         const staleDaysThreshold = options?.staleDaysThreshold ?? DEFAULT_STALE_DAYS;
         const duplicateThreshold = options?.duplicateThreshold ?? DEFAULT_DUPLICATE_THRESHOLD;
         const contradictionThreshold = options?.contradictionThreshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
-        // Detect duplicates
         const duplicates = this.detectDuplicates(undefined, duplicateThreshold);
-        // Detect stale entries
         const now = Math.floor(Date.now() / 1000);
-        const staleThreshold = now - staleDaysThreshold * 86400;
-        const staleRows = this.provider.all('SELECT id FROM entries WHERE updated_at < ?', [staleThreshold]);
+        const staleRows = this.provider.all('SELECT id FROM entries WHERE updated_at < ?', [now - staleDaysThreshold * 86400]);
         const staleEntries = staleRows.map((r) => r.id);
-        // Detect contradictions
         const contradictions = this.detectContradictions(contradictionThreshold);
         let mutations = 0;
         if (!dryRun) {
-            // Archive stale entries
             for (const entryId of staleEntries) {
-                this.provider.run(`INSERT INTO curator_entry_state (entry_id, status, last_groomed_at)
-           VALUES (?, 'archived', unixepoch())
-           ON CONFLICT(entry_id) DO UPDATE SET status = 'archived', last_groomed_at = unixepoch()`, [entryId]);
+                this.provider.run(`INSERT INTO curator_entry_state (entry_id, status, last_groomed_at) VALUES (?, 'archived', unixepoch()) ON CONFLICT(entry_id) DO UPDATE SET status = 'archived', last_groomed_at = unixepoch()`, [entryId]);
                 this.logChange('archive', entryId, 'active', 'archived', 'Stale entry archived during consolidation');
                 mutations++;
             }
-            // Remove lower-similarity duplicates (keep the first entry, remove matches)
             const removed = new Set();
             for (const result of duplicates) {
                 for (const match of result.matches) {
@@ -394,118 +144,24 @@ export class Curator {
                 }
             }
         }
-        return {
-            dryRun,
-            duplicates,
-            staleEntries,
-            contradictions,
-            mutations,
-            durationMs: Date.now() - start,
-        };
+        return { dryRun, duplicates, staleEntries, contradictions, mutations, durationMs: Date.now() - start };
     }
-    // ─── Changelog ──────────────────────────────────────────────────
+    // ─── Changelog ────────────────────────────────────────────────
     getEntryHistory(entryId, limit) {
-        const rows = this.provider.all('SELECT * FROM curator_changelog WHERE entry_id = ? ORDER BY created_at DESC, id DESC LIMIT ?', [entryId, limit ?? 50]);
-        return rows.map((r) => this.rowToChangelog(r));
+        return this.provider.all('SELECT * FROM curator_changelog WHERE entry_id = ? ORDER BY created_at DESC, id DESC LIMIT ?', [entryId, limit ?? 50]).map((r) => this.rowToChangelog(r));
     }
-    // ─── Health Audit ───────────────────────────────────────────────
+    // ─── Health Audit (delegates to health-audit) ─────────────────
     healthAudit() {
         const entries = this.vault.list({ limit: 100000 });
-        const recommendations = [];
-        if (entries.length === 0) {
-            return {
-                score: 100,
-                metrics: { coverage: 1, freshness: 1, quality: 1, tagHealth: 1 },
-                recommendations: ['Vault is empty — add knowledge entries to get started.'],
-            };
-        }
-        let score = 100;
-        // Coverage: penalize if no anti-patterns or no patterns
-        const typeCount = { pattern: 0, 'anti-pattern': 0, rule: 0 };
-        for (const e of entries) {
-            typeCount[e.type] = (typeCount[e.type] ?? 0) + 1;
-        }
-        const hasPatterns = typeCount.pattern > 0;
-        const hasAntiPatterns = typeCount['anti-pattern'] > 0;
-        const hasRules = typeCount.rule > 0;
-        let coverageScore = 1;
-        if (!hasPatterns) {
-            score -= 10;
-            coverageScore -= 0.33;
-            recommendations.push('No patterns found — add patterns to improve coverage.');
-        }
-        if (!hasAntiPatterns) {
-            score -= 5;
-            coverageScore -= 0.17;
-            recommendations.push('No anti-patterns found — add anti-patterns to detect contradictions.');
-        }
-        if (!hasRules) {
-            score -= 5;
-            coverageScore -= 0.17;
-            recommendations.push('No rules found — add rules for completeness.');
-        }
-        coverageScore = Math.max(0, coverageScore);
-        // Freshness: penalize stale entries
-        const now = Math.floor(Date.now() / 1000);
-        const staleThreshold = now - DEFAULT_STALE_DAYS * 86400;
-        const staleCount = (this.provider.get('SELECT COUNT(*) as count FROM entries WHERE updated_at < ?', [staleThreshold]) ?? { count: 0 }).count;
-        const staleRatio = staleCount / entries.length;
-        const freshnessScore = 1 - staleRatio;
-        if (staleRatio > 0.3) {
-            const penalty = Math.min(20, Math.round(staleRatio * 30));
-            score -= penalty;
-            recommendations.push(`${staleCount} stale entries (${Math.round(staleRatio * 100)}%) — run grooming to update.`);
-        }
-        // Quality: penalize duplicates and contradictions
-        const duplicates = this.detectDuplicates();
-        const contradictions = this.getContradictions('open');
-        let qualityScore = 1;
-        if (duplicates.length > 0) {
-            const penalty = Math.min(15, duplicates.length * 3);
-            score -= penalty;
-            qualityScore -= penalty / 30;
-            recommendations.push(`${duplicates.length} entries have duplicates — run consolidation.`);
-        }
-        if (contradictions.length > 0) {
-            const penalty = Math.min(15, contradictions.length * 5);
-            score -= penalty;
-            qualityScore -= penalty / 30;
-            recommendations.push(`${contradictions.length} open contradictions — resolve or dismiss.`);
-        }
-        qualityScore = Math.max(0, qualityScore);
-        // Tag health: penalize entries with few or no tags
-        const lowTagEntries = entries.filter((e) => e.tags.length < 2);
-        const lowTagRatio = lowTagEntries.length / entries.length;
-        const tagHealthScore = 1 - lowTagRatio;
-        if (lowTagRatio > 0.3) {
-            const penalty = Math.min(10, Math.round(lowTagRatio * 15));
-            score -= penalty;
-            recommendations.push(`${lowTagEntries.length} entries have fewer than 2 tags — improve tagging.`);
-        }
-        // Penalize ungroomed entries
-        const groomedCount = (this.provider.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL') ?? { count: 0 }).count;
-        if (groomedCount < entries.length) {
-            const ungroomed = entries.length - groomedCount;
-            const penalty = Math.min(10, Math.round((ungroomed / entries.length) * 10));
-            score -= penalty;
-            recommendations.push(`${ungroomed} entries never groomed — run groomAll().`);
-        }
-        score = Math.max(0, score);
-        if (recommendations.length === 0) {
-            recommendations.push('Vault is healthy — no issues detected.');
-        }
-        return {
-            score,
-            metrics: {
-                coverage: coverageScore,
-                freshness: freshnessScore,
-                quality: qualityScore,
-                tagHealth: tagHealthScore,
-            },
-            recommendations,
+        const dataProvider = {
+            getStaleCount: (threshold) => (this.provider.get('SELECT COUNT(*) as count FROM entries WHERE updated_at < ?', [threshold]) ?? { count: 0 }).count,
+            getGroomedCount: () => (this.provider.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL') ?? { count: 0 }).count,
+            getDuplicates: () => this.detectDuplicates(),
+            getOpenContradictions: () => this.getContradictions('open'),
         };
+        return computeHealthAudit(entries, dataProvider, DEFAULT_STALE_DAYS);
     }
-    // ─── Entry History (Version Snapshots) ─────────────────────────
+    // ─── Entry History (Version Snapshots) ────────────────────────
     recordSnapshot(entryId, changedBy, changeReason) {
         const entry = this.vault.get(entryId);
         if (!entry)
@@ -514,150 +170,59 @@ export class Curator {
         return { recorded: true, historyId: Number(result.lastInsertRowid) };
     }
     getVersionHistory(entryId) {
-        const rows = this.provider.all('SELECT * FROM curator_entry_history WHERE entry_id = ? ORDER BY created_at ASC, id ASC', [entryId]);
-        return rows.map((row) => ({
-            historyId: row.id,
-            entryId: row.entry_id,
-            snapshot: JSON.parse(row.snapshot),
-            changedBy: row.changed_by,
-            changeReason: row.change_reason ?? null,
-            createdAt: row.created_at,
+        return this.provider.all('SELECT * FROM curator_entry_history WHERE entry_id = ? ORDER BY created_at ASC, id ASC', [entryId]).map((row) => ({
+            historyId: row.id, entryId: row.entry_id, snapshot: JSON.parse(row.snapshot), changedBy: row.changed_by, changeReason: row.change_reason ?? null, createdAt: row.created_at,
         }));
     }
-    // ─── Queue Stats ──────────────────────────────────────────────
+    // ─── Queue Stats ─────────────────────────────────────────────
     getQueueStats() {
-        const totalEntries = (this.provider.get('SELECT COUNT(*) as count FROM entries') ?? { count: 0 }).count;
-        const groomedEntries = (this.provider.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL') ?? { count: 0 }).count;
-        const ungroomedEntries = totalEntries - groomedEntries;
+        const p = this.provider;
+        const totalEntries = (p.get('SELECT COUNT(*) as count FROM entries') ?? { count: 0 }).count;
+        const groomedEntries = (p.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL') ?? { count: 0 }).count;
         const now = Math.floor(Date.now() / 1000);
-        const staleThreshold = now - 30 * 86400;
-        const freshThreshold = now - 7 * 86400;
-        const staleEntries = (this.provider.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at < ?', [staleThreshold]) ?? { count: 0 }).count;
-        const freshEntries = (this.provider.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at >= ?', [freshThreshold]) ?? { count: 0 }).count;
+        const staleEntries = (p.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at < ?', [now - 30 * 86400]) ?? { count: 0 }).count;
+        const freshEntries = (p.get('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at >= ?', [now - 7 * 86400]) ?? { count: 0 }).count;
         let avgDaysSinceGroom = 0;
         if (groomedEntries > 0) {
-            const sumRow = this.provider.get('SELECT SUM(? - last_groomed_at) as total FROM curator_entry_state WHERE last_groomed_at IS NOT NULL', [now]) ?? { total: 0 };
-            const totalSeconds = sumRow.total ?? 0;
+            const totalSeconds = (p.get('SELECT SUM(? - last_groomed_at) as total FROM curator_entry_state WHERE last_groomed_at IS NOT NULL', [now]) ?? { total: 0 }).total ?? 0;
             avgDaysSinceGroom = Math.round((totalSeconds / groomedEntries / 86400) * 100) / 100;
         }
-        return {
-            totalEntries,
-            groomedEntries,
-            ungroomedEntries,
-            staleEntries,
-            freshEntries,
-            avgDaysSinceGroom,
-        };
+        return { totalEntries, groomedEntries, ungroomedEntries: totalEntries - groomedEntries, staleEntries, freshEntries, avgDaysSinceGroom };
     }
-    // ─── Metadata Enrichment ──────────────────────────────────────
+    // ─── Metadata Enrichment (delegates to metadata-enricher) ────
     enrichMetadata(entryId) {
         const entry = this.vault.get(entryId);
         if (!entry)
             return { enriched: false, changes: [] };
-        const changes = [];
-        const updates = {};
-        // Auto-capitalize title
-        if (entry.title.length > 0 && entry.title[0] !== entry.title[0].toUpperCase()) {
-            const capitalized = entry.title[0].toUpperCase() + entry.title.slice(1);
-            changes.push({ field: 'title', before: entry.title, after: capitalized });
-            updates.title = capitalized;
-        }
-        // Normalize tags: lowercase, trim, dedup
-        const normalizedTags = [...new Set(entry.tags.map((t) => t.toLowerCase().trim()))];
-        const tagsChanged = normalizedTags.length !== entry.tags.length ||
-            normalizedTags.some((t, i) => t !== entry.tags[i]);
-        if (tagsChanged) {
-            changes.push({
-                field: 'tags',
-                before: JSON.stringify(entry.tags),
-                after: JSON.stringify(normalizedTags),
-            });
-            updates.tags = normalizedTags;
-        }
-        // Infer severity from keywords if currently 'suggestion'
-        if (entry.severity === 'suggestion') {
-            const text = (entry.title + ' ' + entry.description).toLowerCase();
-            const criticalKeywords = ['never', 'must not', 'critical', 'security', 'vulnerability'];
-            const warningKeywords = ['avoid', 'should not', 'deprecated', 'careful', 'warning'];
-            if (criticalKeywords.some((k) => text.includes(k))) {
-                changes.push({ field: 'severity', before: entry.severity, after: 'critical' });
-                updates.severity = 'critical';
-            }
-            else if (warningKeywords.some((k) => text.includes(k))) {
-                changes.push({ field: 'severity', before: entry.severity, after: 'warning' });
-                updates.severity = 'warning';
-            }
-        }
-        // Infer type from title patterns
-        if (entry.type === 'pattern') {
-            const titleLower = entry.title.toLowerCase();
-            if (titleLower.startsWith('avoid') ||
-                titleLower.startsWith('never') ||
-                titleLower.startsWith("don't") ||
-                titleLower.startsWith('do not')) {
-                changes.push({ field: 'type', before: entry.type, after: 'anti-pattern' });
-                updates.type = 'anti-pattern';
-            }
-        }
-        // Trim whitespace from description
-        const trimmed = entry.description.trim();
-        if (trimmed !== entry.description) {
-            changes.push({ field: 'description', before: entry.description, after: trimmed });
-            updates.description = trimmed;
-        }
-        if (changes.length === 0) {
+        const { changes, updates } = enrichEntryMetadata(entry);
+        if (changes.length === 0)
             return { enriched: false, changes: [] };
-        }
-        // Apply updates
         this.vault.update(entryId, updates);
-        // Record snapshot
         this.recordSnapshot(entryId, 'curator', 'Metadata enrichment');
-        // Log change
         this.logChange('enrich_metadata', entryId, JSON.stringify(changes.map((c) => c.field)), JSON.stringify(changes.map((c) => c.after)), 'Rule-based metadata enrichment');
         return { enriched: true, changes };
     }
-    // ─── Private Helpers ────────────────────────────────────────────
-    buildVocabulary(entries) {
-        const docCount = entries.length;
-        const termDocFreq = new Map();
-        for (const entry of entries) {
-            const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
-            const tokens = new Set(tokenize(text));
-            for (const token of tokens) {
-                termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);
+    // ─── Private Helpers ──────────────────────────────────────────
+    persistContradictions(candidates) {
+        const detected = [];
+        for (const c of candidates) {
+            const result = this.provider.run('INSERT OR IGNORE INTO curator_contradictions (pattern_id, antipattern_id, similarity) VALUES (?, ?, ?)', [c.patternId, c.antipatternId, c.similarity]);
+            if (result.changes > 0) {
+                const row = this.provider.get('SELECT * FROM curator_contradictions WHERE pattern_id = ? AND antipattern_id = ?', [c.patternId, c.antipatternId]);
+                if (row)
+                    detected.push(this.rowToContradiction(row));
             }
         }
-        const vocabulary = new Map();
-        for (const [term, df] of termDocFreq) {
-            const idf = Math.log((docCount + 1) / (df + 1)) + 1;
-            vocabulary.set(term, idf);
-        }
-        return vocabulary;
+        return detected;
     }
     logChange(action, entryId, beforeValue, afterValue, reason) {
         this.provider.run('INSERT INTO curator_changelog (action, entry_id, before_value, after_value, reason) VALUES (?, ?, ?, ?, ?)', [action, entryId, beforeValue, afterValue, reason]);
     }
     rowToContradiction(row) {
-        return {
-            id: row.id,
-            patternId: row.pattern_id,
-            antipatternId: row.antipattern_id,
-            similarity: row.similarity,
-            status: row.status,
-            createdAt: row.created_at,
-            resolvedAt: row.resolved_at ?? null,
-        };
+        return { id: row.id, patternId: row.pattern_id, antipatternId: row.antipattern_id, similarity: row.similarity, status: row.status, createdAt: row.created_at, resolvedAt: row.resolved_at ?? null };
     }
     rowToChangelog(row) {
-        return {
-            id: row.id,
-            action: row.action,
-            entryId: row.entry_id,
-            beforeValue: row.before_value ?? null,
-            afterValue: row.after_value ?? null,
-            reason: row.reason,
-            createdAt: row.created_at,
-        };
+        return { id: row.id, action: row.action, entryId: row.entry_id, beforeValue: row.before_value ?? null, afterValue: row.after_value ?? null, reason: row.reason, createdAt: row.created_at };
     }
 }
 //# sourceMappingURL=curator.js.map