@soleri/core 9.0.4 → 9.3.0

package/src/curator/curator.ts

@@ -1,17 +1,10 @@
 import type { Vault } from '../vault/vault.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 import type { PersistenceProvider } from '../persistence/types.js';
-import {
-  tokenize,
-  calculateTfIdf,
-  cosineSimilarity,
-  type SparseVector,
-} from '../text/similarity.js';
 import type {
   CuratorStatus,
   TagNormalizationResult,
   CanonicalTag,
-  DuplicateCandidate,
   DuplicateDetectionResult,
   Contradiction,
   ContradictionStatus,
@@ -23,115 +16,78 @@ import type {
   HealthAuditResult,
 } from './types.js';
 
+import {
+  detectDuplicates as detectDuplicatesPure,
+  DEFAULT_DUPLICATE_THRESHOLD,
+} from './duplicate-detector.js';
+import {
+  findContradictions,
+  DEFAULT_CONTRADICTION_THRESHOLD,
+  type ContradictionCandidate,
+} from './contradiction-detector.js';
+import {
+  normalizeTag as normalizeTagPure,
+  normalizeAndDedup,
+  addTagAlias as addTagAliasPure,
+  getCanonicalTags as getCanonicalTagsPure,
+  seedDefaultAliases,
+  type TagStore,
+} from './tag-manager.js';
+import { initializeTables } from './schema.js';
+import { computeHealthAudit, type HealthDataProvider } 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: Array<[string, string]> = [
-  ['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 {
   private vault: Vault;
   private provider: PersistenceProvider;
+  private tagStore: TagStore;
 
   constructor(vault: 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 ─────────────────────────────────────────────────────
-
-  private initializeTables(): void {
-    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);
-    `);
-  }
-
-  private seedDefaultAliases(): void {
-    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],
+  private createTagStore(): TagStore {
+    const p = this.provider;
+    return {
+      getAlias(lower: string) {
+        return (
+          p.get<{ canonical: string }>('SELECT canonical FROM curator_tag_alias WHERE alias = ?', [
+            lower,
+          ])?.canonical ?? null
         );
-      }
-    });
+      },
+      insertCanonical(tag: string) {
+        p.run('INSERT OR IGNORE INTO curator_tag_canonical (tag) VALUES (?)', [tag]);
+      },
+      upsertAlias(alias: string, canonical: string) {
+        p.run('INSERT OR REPLACE INTO curator_tag_alias (alias, canonical) VALUES (?, ?)', [
+          alias,
+          canonical,
+        ]);
+      },
+      getCanonicalRows() {
+        return p.all<{ tag: string; description: string | null; alias_count: number }>(
+          `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: string) {
+        return (
+          p.get<{ count: number }>('SELECT COUNT(*) as count FROM entries WHERE tags LIKE ?', [
+            `%"${tag}"%`,
+          ])?.count ?? 0
+        );
+      },
+    };
   }
 
   // ─── Status ─────────────────────────────────────────────────────
@@ -143,11 +99,9 @@ export class Curator {
           count: 0,
         }
       ).count;
-
     const lastGroomed = this.provider.get<{ ts: number | null }>(
       'SELECT MAX(last_groomed_at) as ts FROM curator_entry_state WHERE last_groomed_at IS NOT NULL',
     ) ?? { ts: null };
-
     return {
       initialized: true,
       tables: {
@@ -161,37 +115,17 @@ export class Curator {
     };
   }
 
-  // ─── Tag Normalization ──────────────────────────────────────────
+  // ─── Tags (delegates to tag-manager) ──────────────────────────
 
   normalizeTag(tag: string): TagNormalizationResult {
-    const lower = tag.toLowerCase().trim();
-    const row = this.provider.get<{ canonical: string }>(
-      '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 };
+    return normalizeTagPure(tag, this.tagStore);
   }
 
   normalizeTags(entryId: string): TagNormalizationResult[] {
     const entry = this.vault.get(entryId);
     if (!entry) return [];
-
-    const results: TagNormalizationResult[] = [];
-    const normalizedTags: string[] = [];
-    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,
@@ -204,161 +138,39 @@ export class Curator {
         'Tag normalization',
       );
     }
-
     return results;
   }
 
   addTagAlias(alias: string, canonical: string): void {
-    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,
-    ]);
+    addTagAliasPure(alias, canonical, this.tagStore);
   }
-
   getCanonicalTags(): CanonicalTag[] {
-    const rows = this.provider.all<{
-      tag: string;
-      description: string | null;
-      alias_count: number;
-    }>(
-      `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,
-    }));
+    return getCanonicalTagsPure(this.tagStore);
   }
 
-  private countTagUsage(tag: string): number {
-    const row = this.provider.get<{ count: number }>(
-      'SELECT COUNT(*) as count FROM entries WHERE tags LIKE ?',
-      [`%"${tag}"%`],
-    );
-    return row?.count ?? 0;
-  }
-
-  // ─── Duplicate Detection ────────────────────────────────────────
+  // ─── Duplicates (delegates to duplicate-detector) ─────────────
 
   detectDuplicates(entryId?: string, threshold?: number): DuplicateDetectionResult[] {
-    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<string, SparseVector>();
-    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: DuplicateDetectionResult[] = [];
-
-    for (const entry of targetEntries) {
-      const entryVec = vectors.get(entry.id)!;
-      const matches: DuplicateCandidate[] = [];
-
-      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?: number): Contradiction[] {
-    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: Contradiction[] = [];
-
-    for (const ap of antipatterns) {
-      // Stage 1: FTS5 candidate retrieval (fall back to all patterns if FTS returns empty)
-      let candidates: IntelligenceEntry[];
-      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<Record<string, unknown>>(
-              '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: string) =>
+      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?: ContradictionStatus): Contradiction[] {
     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<Record<string, unknown>>(query, status ? [status] : undefined);
-    return rows.map((r) => this.rowToContradiction(r));
+    return this.provider
+      .all<Record<string, unknown>>(query, status ? [status] : undefined)
+      .map((r) => this.rowToContradiction(r));
   }
 
   resolveContradiction(id: number, resolution: 'resolved' | 'dismissed'): Contradiction | null {
@@ -373,103 +185,45 @@ export class Curator {
     return row ? this.rowToContradiction(row) : null;
   }
 
-  async detectContradictionsHybrid(threshold?: number): Promise<{
-    contradictions: Contradiction[];
-    method: 'tfidf-only';
-  }> {
-    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: Contradiction[] = [];
-
-    for (const ap of antipatterns) {
-      let candidates: IntelligenceEntry[];
-      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<Record<string, unknown>>(
-              'SELECT * FROM curator_contradictions WHERE pattern_id = ? AND antipattern_id = ?',
-              [pattern.id, ap.id],
-            );
-            if (row) detected.push(this.rowToContradiction(row));
-          }
-        }
-      }
-    }
-
+  async detectContradictionsHybrid(
+    threshold?: number,
+  ): Promise<{ contradictions: Contradiction[]; method: 'tfidf-only' }> {
+    const searchFn = (title: string) =>
+      this.vault.search(title, { type: 'pattern', limit: 20 }).map((r) => r.entry);
     return {
-      contradictions: detected,
+      contradictions: this.persistContradictions(
+        findContradictions(this.vault.list({ limit: 100000 }), threshold, searchFn),
+      ),
       method: 'tfidf-only',
     };
   }
 
-  // ─── Grooming ───────────────────────────────────────────────────
+  // ─── Grooming ─────────────────────────────────────────────────
 
   groomEntry(entryId: string): GroomResult | null {
     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<{ updated_at: number }>(
       '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()`,
+      `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(): GroomAllResult {
     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) {
@@ -477,7 +231,6 @@ export class Curator {
         if (result.stale) staleCount++;
       }
     }
-
     return {
       totalEntries: entries.length,
       groomedCount: entries.length,
@@ -487,7 +240,7 @@ export class Curator {
     };
   }
 
-  // ─── Consolidation ─────────────────────────────────────────────
+  // ─── Consolidation ───────────────────────────────────────────
 
   consolidate(options?: ConsolidationOptions): ConsolidationResult {
     const start = Date.now();
@@ -496,31 +249,19 @@ export class Curator {
     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<{ id: string }>(
       'SELECT id FROM entries WHERE updated_at < ?',
-      [staleThreshold],
+      [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()`,
+          `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(
@@ -532,8 +273,6 @@ export class Curator {
         );
         mutations++;
       }
-
-      // Remove lower-similarity duplicates (keep the first entry, remove matches)
       const removed = new Set<string>();
       for (const result of duplicates) {
         for (const match of result.matches) {
@@ -552,7 +291,6 @@ export class Curator {
         }
       }
     }
-
     return {
       dryRun,
       duplicates,
@@ -563,139 +301,42 @@ export class Curator {
     };
   }
 
-  // ─── Changelog ──────────────────────────────────────────────────
+  // ─── Changelog ────────────────────────────────────────────────
 
   getEntryHistory(entryId: string, limit?: number): ChangelogEntry[] {
-    const rows = this.provider.all<Record<string, unknown>>(
-      '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<Record<string, unknown>>(
+        '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(): HealthAuditResult {
     const entries = this.vault.list({ limit: 100000 });
-    const recommendations: string[] = [];
-
-    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: Record<string, number> = { 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<{ count: number }>(
-        '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<{ count: number }>(
-        '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: HealthDataProvider = {
+      getStaleCount: (threshold) =>
+        (
+          this.provider.get<{ count: number }>(
+            'SELECT COUNT(*) as count FROM entries WHERE updated_at < ?',
+            [threshold],
+          ) ?? { count: 0 }
+        ).count,
+      getGroomedCount: () =>
+        (
+          this.provider.get<{ count: number }>(
+            '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: string,
@@ -704,12 +345,10 @@ export class Curator {
   ): { recorded: boolean; historyId: number } {
     const entry = this.vault.get(entryId);
     if (!entry) return { recorded: false, historyId: -1 };
-
     const result = this.provider.run(
       'INSERT INTO curator_entry_history (entry_id, snapshot, changed_by, change_reason, created_at) VALUES (?, ?, ?, ?, unixepoch())',
       [entryId, JSON.stringify(entry), changedBy ?? 'system', changeReason ?? null],
     );
-
     return { recorded: true, historyId: Number(result.lastInsertRowid) };
   }
 
@@ -721,22 +360,22 @@ export class Curator {
     changeReason: string | null;
     createdAt: number;
   }> {
-    const rows = this.provider.all<Record<string, unknown>>(
-      'SELECT * FROM curator_entry_history WHERE entry_id = ? ORDER BY created_at ASC, id ASC',
-      [entryId],
-    );
-
-    return rows.map((row) => ({
-      historyId: row.id as number,
-      entryId: row.entry_id as string,
-      snapshot: JSON.parse(row.snapshot as string) as IntelligenceEntry,
-      changedBy: row.changed_by as string,
-      changeReason: (row.change_reason as string) ?? null,
-      createdAt: row.created_at as number,
-    }));
+    return this.provider
+      .all<Record<string, unknown>>(
+        'SELECT * FROM curator_entry_history WHERE entry_id = ? ORDER BY created_at ASC, id ASC',
+        [entryId],
+      )
+      .map((row) => ({
+        historyId: row.id as number,
+        entryId: row.entry_id as string,
+        snapshot: JSON.parse(row.snapshot as string) as IntelligenceEntry,
+        changedBy: row.changed_by as string,
+        changeReason: (row.change_reason as string) ?? null,
+        createdAt: row.created_at as number,
+      }));
   }
 
-  // ─── Queue Stats ──────────────────────────────────────────────
+  // ─── Queue Stats ─────────────────────────────────────────────
 
   getQueueStats(): {
     totalEntries: number;
@@ -746,57 +385,50 @@ export class Curator {
     freshEntries: number;
     avgDaysSinceGroom: number;
   } {
+    const p = this.provider;
     const totalEntries = (
-      this.provider.get<{ count: number }>('SELECT COUNT(*) as count FROM entries') ?? { count: 0 }
+      p.get<{ count: number }>('SELECT COUNT(*) as count FROM entries') ?? { count: 0 }
     ).count;
-
     const groomedEntries = (
-      this.provider.get<{ count: number }>(
+      p.get<{ count: number }>(
         'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL',
       ) ?? { count: 0 }
     ).count;
-
-    const ungroomedEntries = totalEntries - groomedEntries;
-
     const now = Math.floor(Date.now() / 1000);
-    const staleThreshold = now - 30 * 86400;
-    const freshThreshold = now - 7 * 86400;
-
     const staleEntries = (
-      this.provider.get<{ count: number }>(
+      p.get<{ count: number }>(
         'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at < ?',
-        [staleThreshold],
+        [now - 30 * 86400],
       ) ?? { count: 0 }
     ).count;
-
     const freshEntries = (
-      this.provider.get<{ count: number }>(
+      p.get<{ count: number }>(
         'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at >= ?',
-        [freshThreshold],
+        [now - 7 * 86400],
       ) ?? { count: 0 }
     ).count;
-
     let avgDaysSinceGroom = 0;
     if (groomedEntries > 0) {
-      const sumRow = this.provider.get<{ total: number | null }>(
-        '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<{ total: number | null }>(
+            '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,
+      ungroomedEntries: totalEntries - groomedEntries,
       staleEntries,
       freshEntries,
       avgDaysSinceGroom,
     };
   }
 
-  // ─── Metadata Enrichment ──────────────────────────────────────
+  // ─── Metadata Enrichment (delegates to metadata-enricher) ────
 
   enrichMetadata(entryId: string): {
     enriched: boolean;
@@ -804,79 +436,10 @@ export class Curator {
   } {
     const entry = this.vault.get(entryId);
     if (!entry) return { enriched: false, changes: [] };
-
-    const changes: Array<{ field: string; before: string; after: string }> = [];
-    const updates: Partial<
-      Pick<IntelligenceEntry, 'title' | 'description' | 'tags' | 'severity' | 'type'>
-    > = {};
-
-    // 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) {
-      return { enriched: false, changes: [] };
-    }
-
-    // Apply updates
+    const { changes, updates } = enrichEntryMetadata(entry);
+    if (changes.length === 0) return { enriched: false, changes: [] };
     this.vault.update(entryId, updates);
-
-    // Record snapshot
     this.recordSnapshot(entryId, 'curator', 'Metadata enrichment');
-
-    // Log change
     this.logChange(
       'enrich_metadata',
       entryId,
@@ -884,30 +447,27 @@ export class Curator {
       JSON.stringify(changes.map((c) => c.after)),
       'Rule-based metadata enrichment',
     );
-
     return { enriched: true, changes };
   }
 
-  // ─── Private Helpers ────────────────────────────────────────────
+  // ─── Private Helpers ──────────────────────────────────────────
 
-  private buildVocabulary(entries: IntelligenceEntry[]): Map<string, number> {
-    const docCount = entries.length;
-    const termDocFreq = new Map<string, number>();
-    for (const entry of entries) {
-      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(
-        ' ',
+  private persistContradictions(candidates: ContradictionCandidate[]): Contradiction[] {
+    const detected: Contradiction[] = [];
+    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],
       );
-      const tokens = new Set(tokenize(text));
-      for (const token of tokens) {
-        termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);
+      if (result.changes > 0) {
+        const row = this.provider.get<Record<string, unknown>>(
+          '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<string, number>();
-    for (const [term, df] of termDocFreq) {
-      const idf = Math.log((docCount + 1) / (df + 1)) + 1;
-      vocabulary.set(term, idf);
-    }
-    return vocabulary;
+    return detected;
   }
 
   private logChange(