@kybernesis/brain-core 0.2.0 → 0.5.0

package/dist/entity-graph.js

@@ -1,299 +1,30 @@
-import { getDb } from '@kybernesis/brain-storage-sqlite';
-import { DIRECTIONAL_RELATIONSHIPS } from '@kybernesis/brain-contracts';
-function rowToEntity(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        normalized_name: row.normalized_name,
-        aliases: JSON.parse(row.aliases || '[]'),
-        type: row.type,
-        first_seen: row.first_seen,
-        last_seen: row.last_seen,
-        mention_count: row.mention_count,
-        priority: row.priority ?? 0.5,
-        decay_score: row.decay_score ?? 0.0,
-        tier: (row.tier ?? 'warm'),
-        last_accessed: row.last_accessed ?? undefined,
-        access_count: row.access_count ?? 0,
-        is_pinned: (row.is_pinned ?? 0) === 1,
-        last_reasoned_at: row.last_reasoned_at ?? undefined,
-    };
-}
-function rowToMention(row) {
-    return {
-        id: row.id,
-        entity_id: row.entity_id,
-        conversation_id: row.conversation_id,
-        source_path: row.source_path,
-        context: row.context ?? undefined,
-        timestamp: row.timestamp,
-        source_type: row.source_type ?? 'chat',
-        confidence: row.confidence ?? 0.85,
-    };
-}
-function rowToInsight(row) {
-    return {
-        id: row.id,
-        entity_id: row.entity_id,
-        insight_type: row.insight_type,
-        insight: row.insight,
-        reasoning: row.reasoning,
-        confidence: row.confidence,
-        source_entity_ids: JSON.parse(row.source_entity_ids || '[]'),
-        created_at: row.created_at,
-        expires_at: row.expires_at ?? undefined,
-        is_stale: (row.is_stale ?? 0) === 1,
-    };
-}
-// ─── Schema initialization ────────────────────────────────────────────────────
-const initialized = new Set();
-function ensureSchema(t) {
-    if (initialized.has(t.slug))
-        return;
-    const db = getDb(t, 'entityGraph');
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS entities (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL,
-      normalized_name TEXT NOT NULL,
-      aliases TEXT DEFAULT '[]',
-      type TEXT NOT NULL CHECK(type IN ('person', 'company', 'project', 'place', 'topic')),
-      first_seen TEXT NOT NULL,
-      last_seen TEXT NOT NULL,
-      mention_count INTEGER DEFAULT 1,
-      priority REAL DEFAULT 0.5,
-      decay_score REAL DEFAULT 0.0,
-      tier TEXT DEFAULT 'warm',
-      last_accessed TEXT,
-      access_count INTEGER DEFAULT 0,
-      is_pinned INTEGER DEFAULT 0,
-      last_reasoned_at TEXT,
-      UNIQUE(normalized_name, type)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_entities_normalized ON entities(normalized_name);
-    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
-    CREATE INDEX IF NOT EXISTS idx_entities_tier ON entities(tier);
-    CREATE INDEX IF NOT EXISTS idx_entities_priority ON entities(priority DESC);
-
-    CREATE TABLE IF NOT EXISTS entity_mentions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      entity_id INTEGER NOT NULL,
-      conversation_id TEXT NOT NULL,
-      source_path TEXT NOT NULL,
-      context TEXT,
-      timestamp TEXT NOT NULL,
-      source_type TEXT DEFAULT 'chat',
-      confidence REAL DEFAULT 0.85,
-      FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_mentions_conversation ON entity_mentions(conversation_id);
-    CREATE INDEX IF NOT EXISTS idx_mentions_entity ON entity_mentions(entity_id);
-    CREATE INDEX IF NOT EXISTS idx_mentions_timestamp ON entity_mentions(timestamp);
-
-    CREATE TABLE IF NOT EXISTS entity_relations (
-      source_id INTEGER NOT NULL,
-      target_id INTEGER NOT NULL,
-      relationship TEXT DEFAULT 'co-occurred',
-      strength INTEGER DEFAULT 1,
-      confidence REAL DEFAULT 0.5,
-      method TEXT DEFAULT 'co-occurred',
-      rationale TEXT,
-      last_verified TEXT,
-      PRIMARY KEY (source_id, target_id),
-      FOREIGN KEY (source_id) REFERENCES entities(id) ON DELETE CASCADE,
-      FOREIGN KEY (target_id) REFERENCES entities(id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_relations_source ON entity_relations(source_id);
-    CREATE INDEX IF NOT EXISTS idx_relations_target ON entity_relations(target_id);
-    CREATE INDEX IF NOT EXISTS idx_relations_confidence ON entity_relations(confidence DESC);
-
-    CREATE TABLE IF NOT EXISTS entity_merges (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      keep_id INTEGER NOT NULL,
-      remove_id INTEGER NOT NULL,
-      keep_name TEXT, remove_name TEXT, keep_type TEXT, remove_type TEXT,
-      reason TEXT NOT NULL,
-      confidence REAL,
-      ai_rationale TEXT,
-      mentions_moved INTEGER DEFAULT 0,
-      relations_moved INTEGER DEFAULT 0,
-      merged_at TEXT DEFAULT (datetime('now')),
-      merged_by TEXT DEFAULT 'sleep:entity-hygiene'
-    );
-
-    CREATE TABLE IF NOT EXISTS entity_profiles (
-      entity_id INTEGER PRIMARY KEY REFERENCES entities(id) ON DELETE CASCADE,
-      profile TEXT NOT NULL,
-      generated_at TEXT DEFAULT (datetime('now')),
-      fact_count INTEGER DEFAULT 0
-    );
-
-    CREATE TABLE IF NOT EXISTS contradictions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      entity_id INTEGER,
-      fact_a_id INTEGER,
-      fact_b_id INTEGER,
-      fact_a TEXT,
-      fact_b TEXT,
-      description TEXT,
-      status TEXT DEFAULT 'open',
-      resolved_by TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_contradictions_entity ON contradictions(entity_id);
-    CREATE INDEX IF NOT EXISTS idx_contradictions_status ON contradictions(status);
-
-    CREATE TABLE IF NOT EXISTS entity_insights (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
-      insight_type TEXT NOT NULL,
-      insight TEXT NOT NULL,
-      reasoning TEXT NOT NULL,
-      confidence REAL DEFAULT 0.70,
-      source_entity_ids TEXT DEFAULT '[]',
-      created_at TEXT DEFAULT (datetime('now')),
-      expires_at TEXT,
-      is_stale INTEGER DEFAULT 0
-    );
-    CREATE INDEX IF NOT EXISTS idx_insights_entity ON entity_insights(entity_id);
-    CREATE INDEX IF NOT EXISTS idx_insights_type ON entity_insights(insight_type);
-  `);
-    initialized.add(t.slug);
-}
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function normalizeEntityName(name) {
-    return name.toLowerCase().trim().replace(/\s+/g, ' ');
-}
-function escapeLike(value) {
-    return value.replace(/[%_\\]/g, ch => `\\${ch}`);
-}
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-// ─── Entity operations ────────────────────────────────────────────────────────
+/**
+ * Entity graph — public API. Storage now lives behind the seam
+ * (getStorage().entities); these are thin, signature-stable delegators plus the
+ * `linkEntitiesFromConversation` orchestrator that composes findOrCreateEntity +
+ * addEntityMention (Stage 1, G3). The two internal transactions (mergeEntities,
+ * deleteEntity) and the historical merge-edge-relocation fix live in the impl.
+ */
+import { getStorage } from './storage.js';
 export async function findOrCreateEntity(t, name, type, timestamp) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const normalizedName = normalizeEntityName(name);
-    let existing = db.prepare('SELECT * FROM entities WHERE normalized_name = ? AND type = ?')
-        .get(normalizedName, type);
-    if (!existing) {
-        existing = db.prepare(`SELECT * FROM entities WHERE type = ? AND LOWER(aliases) LIKE ? ESCAPE '\\'`)
-            .get(type, `%"${escapeLike(normalizedName)}"%`);
-    }
-    if (existing) {
-        db.prepare('UPDATE entities SET last_seen = ?, mention_count = mention_count + 1 WHERE id = ?')
-            .run(timestamp, existing.id);
-        return rowToEntity({ ...existing, last_seen: timestamp, mention_count: existing.mention_count + 1 });
-    }
-    const result = db.prepare(`
-    INSERT INTO entities (name, normalized_name, aliases, type, first_seen, last_seen, mention_count)
-    VALUES (?, ?, ?, ?, ?, ?, 1)
-  `).run(name, normalizedName, '[]', type, timestamp, timestamp);
-    return {
-        id: result.lastInsertRowid,
-        name,
-        normalized_name: normalizedName,
-        aliases: [],
-        type,
-        first_seen: timestamp,
-        last_seen: timestamp,
-        mention_count: 1,
-        priority: 0.5,
-        decay_score: 0.0,
-        tier: 'warm',
-        access_count: 0,
-        is_pinned: false,
-    };
+    return getStorage().entities.findOrCreateEntity(t, name, type, timestamp);
 }
 export async function addEntityAlias(t, entityId, alias) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const entity = db.prepare('SELECT aliases FROM entities WHERE id = ?').get(entityId);
-    if (!entity)
-        return;
-    const aliases = JSON.parse(entity.aliases);
-    const normalizedAlias = normalizeEntityName(alias);
-    if (!aliases.includes(normalizedAlias)) {
-        aliases.push(normalizedAlias);
-        db.prepare('UPDATE entities SET aliases = ? WHERE id = ?').run(JSON.stringify(aliases), entityId);
-    }
+    return getStorage().entities.addEntityAlias(t, entityId, alias);
 }
 export async function addEntityMention(t, entityId, conversationId, sourcePath, context, timestamp, sourceType = 'chat', confidence = 0.85) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    db.prepare(`
-    INSERT INTO entity_mentions (entity_id, conversation_id, source_path, context, timestamp, source_type, confidence)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(entityId, conversationId, sourcePath, context, timestamp, sourceType, confidence);
+    return getStorage().entities.addEntityMention(t, entityId, conversationId, sourcePath, context, timestamp, sourceType, confidence);
 }
 export async function linkEntities(t, sourceId, targetId, relationship = 'co-occurred') {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const [id1, id2] = sourceId < targetId ? [sourceId, targetId] : [targetId, sourceId];
-    db.prepare(`
-    INSERT INTO entity_relations (source_id, target_id, relationship, strength)
-    VALUES (?, ?, ?, 1)
-    ON CONFLICT(source_id, target_id) DO UPDATE SET strength = strength + 1
-  `).run(id1, id2, relationship);
+    return getStorage().entities.linkEntities(t, sourceId, targetId, relationship);
 }
 export async function linkEntitiesWithType(t, sourceId, targetId, options) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const isDirectional = DIRECTIONAL_RELATIONSHIPS.has(options.relationship);
-    const [id1, id2] = isDirectional
-        ? [sourceId, targetId]
-        : sourceId < targetId ? [sourceId, targetId] : [targetId, sourceId];
-    const confidence = options.confidence ?? 0.7;
-    const method = options.method ?? 'ai-extraction';
-    const now = new Date().toISOString();
-    db.prepare(`
-    INSERT INTO entity_relations (source_id, target_id, relationship, strength, confidence, method, rationale, last_verified)
-    VALUES (?, ?, ?, 1, ?, ?, ?, ?)
-    ON CONFLICT(source_id, target_id) DO UPDATE SET
-      relationship = CASE
-        WHEN excluded.confidence > entity_relations.confidence THEN excluded.relationship
-        ELSE entity_relations.relationship
-      END,
-      strength = strength + 1,
-      confidence = MAX(entity_relations.confidence, excluded.confidence),
-      rationale = COALESCE(excluded.rationale, entity_relations.rationale),
-      last_verified = excluded.last_verified
-  `).run(id1, id2, options.relationship, confidence, method, options.rationale ?? null, now);
+    return getStorage().entities.linkEntitiesWithType(t, sourceId, targetId, options);
 }
 export async function getTypedRelationships(t, entityId) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const results = db.prepare(`
-    SELECT
-      er.source_id, er.target_id, er.relationship, er.confidence, er.rationale,
-      e.id, e.name, e.normalized_name, e.type, e.aliases,
-      e.first_seen, e.last_seen, e.mention_count, e.priority, e.decay_score,
-      e.tier, e.last_accessed, e.access_count, e.is_pinned, e.last_reasoned_at
-    FROM entity_relations er
-    JOIN entities e ON (
-      CASE WHEN er.source_id = ? THEN er.target_id ELSE er.source_id END = e.id
-    )
-    WHERE (er.source_id = ? OR er.target_id = ?)
-      AND er.relationship != 'co-occurred'
-    ORDER BY er.confidence DESC, er.strength DESC
-  `).all(entityId, entityId, entityId);
-    return results.map(row => ({
-        entity: rowToEntity({
-            id: row.id, name: row.name, normalized_name: row.normalized_name, type: row.type, aliases: row.aliases,
-            first_seen: row.first_seen, last_seen: row.last_seen, mention_count: row.mention_count,
-            priority: row.priority, decay_score: row.decay_score, tier: row.tier, last_accessed: row.last_accessed,
-            access_count: row.access_count, is_pinned: row.is_pinned, last_reasoned_at: row.last_reasoned_at,
-        }),
-        relationship: row.relationship,
-        direction: row.source_id === entityId ? 'outgoing' : 'incoming',
-        confidence: row.confidence ?? 0.5,
-        rationale: row.rationale ?? undefined,
-    }));
+    return getStorage().entities.getTypedRelationships(t, entityId);
 }
+/** Orchestrator: compose findOrCreateEntity + addEntityMention per entity. */
 export async function linkEntitiesFromConversation(t, conversationId, sourcePath, timestamp, entities) {
     if (entities.length === 0)
         return;
@@ -302,310 +33,67 @@ export async function linkEntitiesFromConversation(t, conversationId, sourcePath
         await addEntityMention(t, dbEntity.id, conversationId, sourcePath, entity.context ?? '', timestamp);
     }
 }
-// ─── Query operations ─────────────────────────────────────────────────────────
 export async function getEntityContext(t, nameOrId) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    let entity;
-    if (typeof nameOrId === 'number') {
-        entity = db.prepare('SELECT * FROM entities WHERE id = ?').get(nameOrId);
-    }
-    else {
-        const normalized = normalizeEntityName(nameOrId);
-        entity = db.prepare(`SELECT * FROM entities WHERE normalized_name = ? OR aliases LIKE ? ESCAPE '\\'`)
-            .get(normalized, `%"${escapeLike(normalized)}"%`);
-    }
-    if (!entity)
-        return null;
-    const mentions = db.prepare('SELECT * FROM entity_mentions WHERE entity_id = ? ORDER BY timestamp DESC').all(entity.id)
-        .map(rowToMention);
-    const relations = db.prepare(`
-    SELECT
-      CASE WHEN source_id = ? THEN target_id ELSE source_id END as related_id,
-      relationship, strength
-    FROM entity_relations
-    WHERE source_id = ? OR target_id = ?
-    ORDER BY strength DESC LIMIT 20
-  `).all(entity.id, entity.id, entity.id);
-    const relatedEntities = relations.flatMap(rel => {
-        const related = db.prepare('SELECT * FROM entities WHERE id = ?').get(rel.related_id);
-        if (!related)
-            return [];
-        return [{ entity: rowToEntity(related), relationship: rel.relationship, strength: rel.strength }];
-    });
-    return { entity: rowToEntity(entity), mentions, relatedEntities };
+    return getStorage().entities.getEntityContext(t, nameOrId);
 }
 export async function searchEntities(t, query, options = {}) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const normalized = normalizeEntityName(query);
-    const escaped = escapeLike(normalized);
-    const limit = options.limit ?? 20;
-    let sql = `SELECT * FROM entities WHERE (normalized_name LIKE ? ESCAPE '\\' OR aliases LIKE ? ESCAPE '\\')`;
-    const params = [`%${escaped}%`, `%${escaped}%`];
-    if (options.type) {
-        sql += ' AND type = ?';
-        params.push(options.type);
-    }
-    sql += ' ORDER BY mention_count DESC LIMIT ?';
-    params.push(limit);
-    return db.prepare(sql).all(...params).map(rowToEntity);
+    return getStorage().entities.searchEntities(t, query, options);
 }
 export async function getRecentEntities(t, limit = 20) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    return db.prepare('SELECT * FROM entities ORDER BY last_seen DESC LIMIT ?').all(limit).map(rowToEntity);
+    return getStorage().entities.getRecentEntities(t, limit);
 }
 export async function getMostMentionedEntities(t, options = {}) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const limit = options.limit ?? 20;
-    let sql = 'SELECT * FROM entities';
-    const params = [];
-    if (options.type) {
-        sql += ' WHERE type = ?';
-        params.push(options.type);
-    }
-    sql += ' ORDER BY mention_count DESC LIMIT ?';
-    params.push(limit);
-    return db.prepare(sql).all(...params).map(rowToEntity);
+    return getStorage().entities.getMostMentionedEntities(t, options);
 }
 export async function getEntityGraphStats(t) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const { count: totalEntities } = db.prepare('SELECT COUNT(*) as count FROM entities').get();
-    const { count: totalMentions } = db.prepare('SELECT COUNT(*) as count FROM entity_mentions').get();
-    const { count: totalRelations } = db.prepare('SELECT COUNT(*) as count FROM entity_relations').get();
-    const byTypeRows = db.prepare('SELECT type, COUNT(*) as count FROM entities GROUP BY type').all();
-    const byType = { person: 0, company: 0, project: 0, place: 0, topic: 0 };
-    for (const row of byTypeRows)
-        byType[row.type] = row.count;
-    return { totalEntities, totalMentions, totalRelations, byType };
+    return getStorage().entities.stats(t);
 }
 export async function detectEntitiesInQuery(t, query) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const allEntities = db.prepare(`
-    SELECT name, normalized_name, type FROM entities
-    WHERE type IN ('person', 'project', 'company')
-    ORDER BY mention_count DESC
-  `).all();
-    const detectedEntities = [];
-    let remainingQuery = query;
-    for (const entity of allEntities) {
-        const nameRegex = new RegExp(`\\b${escapeRegex(entity.name.toLowerCase())}\\b`, 'i');
-        const normalizedRegex = new RegExp(`\\b${escapeRegex(entity.normalized_name.toLowerCase())}\\b`, 'i');
-        if (nameRegex.test(query) || normalizedRegex.test(query)) {
-            detectedEntities.push(entity.name);
-            remainingQuery = remainingQuery.replace(nameRegex, '').replace(normalizedRegex, '');
-        }
-    }
-    remainingQuery = remainingQuery.replace(/\b(and|or|with|about)\b/gi, '').replace(/\s+/g, ' ').trim();
-    return { entities: detectedEntities, remainingQuery };
+    return getStorage().entities.detectEntitiesInQuery(t, query);
 }
-// ─── Merge + delete ───────────────────────────────────────────────────────────
 export async function mergeEntities(t, keepId, removeId, reason, confidence, aiRationale, mergedBy) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const keepEntity = db.prepare('SELECT * FROM entities WHERE id = ?').get(keepId);
-    const removeEntity = db.prepare('SELECT * FROM entities WHERE id = ?').get(removeId);
-    if (!keepEntity || !removeEntity)
-        throw new Error(`Entity not found: keep=${keepId} remove=${removeId}`);
-    let mentionsMoved = 0;
-    let relationsMoved = 0;
-    const doMerge = db.transaction(() => {
-        const mentionResult = db.prepare('UPDATE entity_mentions SET entity_id = ? WHERE entity_id = ?').run(keepId, removeId);
-        mentionsMoved = mentionResult.changes;
-        const entityExists = (id) => db.prepare('SELECT 1 FROM entities WHERE id = ?').get(id) !== undefined;
-        for (const rel of db.prepare('SELECT * FROM entity_relations WHERE source_id = ?').all(removeId)) {
-            const targetId = rel.target_id === removeId ? keepId : rel.target_id;
-            if (targetId === keepId || !entityExists(targetId))
-                continue;
-            const existing = db.prepare('SELECT 1 FROM entity_relations WHERE source_id = ? AND target_id = ?').get(keepId, targetId);
-            if (existing) {
-                db.prepare('UPDATE entity_relations SET strength = strength + ?, confidence = MAX(confidence, ?) WHERE source_id = ? AND target_id = ?')
-                    .run(rel.strength, rel.confidence ?? 0.5, keepId, targetId);
-            }
-            else {
-                db.prepare('INSERT INTO entity_relations (source_id, target_id, relationship, strength, confidence, method, rationale) VALUES (?, ?, ?, ?, ?, ?, ?)')
-                    .run(keepId, targetId, rel.relationship, rel.strength, rel.confidence ?? 0.5, rel.method ?? 'merged', rel.rationale ?? null);
-                relationsMoved++;
-            }
-        }
-        for (const rel of db.prepare('SELECT * FROM entity_relations WHERE target_id = ?').all(removeId)) {
-            const sourceId = rel.source_id === removeId ? keepId : rel.source_id;
-            if (sourceId === keepId || !entityExists(sourceId))
-                continue;
-            const existing = db.prepare('SELECT 1 FROM entity_relations WHERE source_id = ? AND target_id = ?').get(sourceId, keepId);
-            if (existing) {
-                db.prepare('UPDATE entity_relations SET strength = strength + ?, confidence = MAX(confidence, ?) WHERE source_id = ? AND target_id = ?')
-                    .run(rel.strength, rel.confidence ?? 0.5, sourceId, keepId);
-            }
-            else {
-                db.prepare('INSERT INTO entity_relations (source_id, target_id, relationship, strength, confidence, method, rationale) VALUES (?, ?, ?, ?, ?, ?, ?)')
-                    .run(sourceId, keepId, rel.relationship, rel.strength, rel.confidence ?? 0.5, rel.method ?? 'merged', rel.rationale ?? null);
-                relationsMoved++;
-            }
-        }
-        db.prepare('DELETE FROM entity_relations WHERE source_id = ? OR target_id = ?').run(removeId, removeId);
-        db.prepare('DELETE FROM entity_relations WHERE source_id = ? AND target_id = ?').run(keepId, keepId);
-        const keepAliases = JSON.parse(keepEntity.aliases || '[]');
-        const removeAliases = JSON.parse(removeEntity.aliases || '[]');
-        const allAliases = new Set([...keepAliases, ...removeAliases, normalizeEntityName(removeEntity.name)]);
-        allAliases.delete(normalizeEntityName(keepEntity.name));
-        db.prepare('UPDATE entities SET aliases = ? WHERE id = ?').run(JSON.stringify([...allAliases]), keepId);
-        db.prepare(`
-      UPDATE entities SET
-        mention_count = mention_count + ?,
-        first_seen = MIN(first_seen, ?),
-        last_seen = MAX(last_seen, ?)
-      WHERE id = ?
-    `).run(removeEntity.mention_count, removeEntity.first_seen, removeEntity.last_seen, keepId);
-        db.prepare(`
-      INSERT INTO entity_merges (keep_id, remove_id, keep_name, remove_name, keep_type, remove_type, reason, confidence, ai_rationale, mentions_moved, relations_moved, merged_by)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(keepId, removeId, keepEntity.name, removeEntity.name, keepEntity.type, removeEntity.type, reason, confidence ?? null, aiRationale ?? null, mentionsMoved, relationsMoved, mergedBy ?? 'sleep:entity-hygiene');
-        db.prepare('DELETE FROM entities WHERE id = ?').run(removeId);
-    });
-    doMerge();
-    return { mentions_moved: mentionsMoved, relations_moved: relationsMoved };
+    return getStorage().entities.mergeEntities(t, keepId, removeId, reason, confidence, aiRationale, mergedBy);
 }
 export async function deleteEntity(t, entityId, reason, mergedBy) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const entity = db.prepare('SELECT * FROM entities WHERE id = ?').get(entityId);
-    if (!entity)
-        return;
-    const doDelete = db.transaction(() => {
-        const mentionCount = db.prepare('SELECT COUNT(*) as c FROM entity_mentions WHERE entity_id = ?').get(entityId).c;
-        const relCount = db.prepare('SELECT COUNT(*) as c FROM entity_relations WHERE source_id = ? OR target_id = ?').get(entityId, entityId).c;
-        db.prepare('DELETE FROM entity_mentions WHERE entity_id = ?').run(entityId);
-        db.prepare('DELETE FROM entity_relations WHERE source_id = ? OR target_id = ?').run(entityId, entityId);
-        db.prepare('DELETE FROM entities WHERE id = ?').run(entityId);
-        db.prepare(`
-      INSERT INTO entity_merges (keep_id, remove_id, keep_name, remove_name, keep_type, remove_type, reason, mentions_moved, relations_moved, merged_by)
-      VALUES (0, ?, NULL, ?, NULL, ?, ?, ?, ?, ?)
-    `).run(entityId, entity.name, entity.type, reason, mentionCount, relCount, mergedBy ?? 'sleep:entity-hygiene');
-    });
-    doDelete();
+    return getStorage().entities.deleteEntity(t, entityId, reason, mergedBy);
 }
-// ─── Entity profiles ──────────────────────────────────────────────────────────
 export async function getEntityProfile(t, entityId) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const row = db.prepare('SELECT profile, generated_at, fact_count FROM entity_profiles WHERE entity_id = ?')
-        .get(entityId);
-    if (!row)
-        return null;
-    return { profile: row.profile, generated_at: row.generated_at, fact_count: row.fact_count };
+    return getStorage().entities.getEntityProfile(t, entityId);
 }
 export async function saveEntityProfile(t, entityId, profile, factCount) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    db.prepare(`
-    INSERT INTO entity_profiles (entity_id, profile, generated_at, fact_count)
-    VALUES (?, ?, datetime('now'), ?)
-    ON CONFLICT(entity_id) DO UPDATE SET
-      profile = excluded.profile,
-      generated_at = excluded.generated_at,
-      fact_count = excluded.fact_count
-  `).run(entityId, profile, factCount);
+    return getStorage().entities.saveEntityProfile(t, entityId, profile, factCount);
 }
-// ─── Contradictions ───────────────────────────────────────────────────────────
 export async function createContradiction(t, entityId, factAId, factBId, factA, factB, description) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const result = db.prepare(`
-    INSERT INTO contradictions (entity_id, fact_a_id, fact_b_id, fact_a, fact_b, description)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `).run(entityId, factAId, factBId, factA, factB, description);
-    return result.lastInsertRowid;
+    return getStorage().entities.createContradiction(t, entityId, factAId, factBId, factA, factB, description);
 }
 export async function getOpenContradictions(t, entityId) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const rows = db.prepare(`SELECT * FROM contradictions WHERE entity_id = ? AND status = 'open'`).all(entityId);
-    return rows.map(r => ({
-        id: r.id, entity_id: r.entity_id ?? undefined, fact_a_id: r.fact_a_id ?? undefined,
-        fact_b_id: r.fact_b_id ?? undefined, fact_a: r.fact_a ?? undefined, fact_b: r.fact_b ?? undefined,
-        description: r.description ?? undefined, status: r.status,
-        resolved_by: r.resolved_by ?? undefined, created_at: r.created_at,
-    }));
+    return getStorage().entities.getOpenContradictions(t, entityId);
 }
 export async function resolveContradiction(t, contradictionId, resolvedBy) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    db.prepare(`UPDATE contradictions SET status = 'resolved', resolved_by = ? WHERE id = ?`).run(resolvedBy, contradictionId);
+    return getStorage().entities.resolveContradiction(t, contradictionId, resolvedBy);
 }
 export async function applyContradictions(t, entityId, factIds) {
-    // Placeholder: contradiction application logic is in fact-contradiction module (Day 3).
-    // This stub marks contradictions as resolved when caller provides the winning fact ids.
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    if (factIds.length > 0) {
-        db.prepare(`UPDATE contradictions SET status = 'resolved', resolved_by = 'sleep:observe' WHERE entity_id = ? AND status = 'open'`)
-            .run(entityId);
-    }
+    return getStorage().entities.applyContradictions(t, entityId, factIds);
 }
-// ─── Entity insights ──────────────────────────────────────────────────────────
 export async function saveEntityInsight(t, entityId, insightType, insight, reasoning, confidence, sourceEntityIds = [], expiresAt) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const result = db.prepare(`
-    INSERT INTO entity_insights (entity_id, insight_type, insight, reasoning, confidence, source_entity_ids, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(entityId, insightType, insight, reasoning, confidence, JSON.stringify(sourceEntityIds), expiresAt ?? null);
-    return result.lastInsertRowid;
+    return getStorage().entities.saveEntityInsight(t, entityId, insightType, insight, reasoning, confidence, sourceEntityIds, expiresAt);
 }
 export async function getEntityInsights(t, entityId, minConfidence = 0.60) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    const rows = db.prepare(`
-    SELECT * FROM entity_insights
-    WHERE entity_id = ? AND is_stale = 0 AND confidence >= ?
-      AND (expires_at IS NULL OR expires_at > datetime('now'))
-    ORDER BY confidence DESC, created_at DESC
-  `).all(entityId, minConfidence);
-    return rows.map(rowToInsight);
+    return getStorage().entities.getEntityInsights(t, entityId, minConfidence);
 }
 export async function markInsightsStale(t, entityId) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    db.prepare('UPDATE entity_insights SET is_stale = 1 WHERE entity_id = ?').run(entityId);
+    return getStorage().entities.markInsightsStale(t, entityId);
 }
 export async function getEntitiesForReasoning(t, limit = 5, staleDays = 7, recencyDays = 14) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    return db.prepare(`
-    SELECT id, name, type FROM entities
-    WHERE mention_count >= 3
-      AND (last_reasoned_at IS NULL OR last_reasoned_at < datetime('now', ?))
-      AND (last_seen IS NULL OR last_seen > datetime('now', ?))
-    ORDER BY mention_count DESC
-    LIMIT ?
-  `).all(`-${staleDays} days`, `-${recencyDays} days`, limit);
+    return getStorage().entities.getEntitiesForReasoning(t, limit, staleDays, recencyDays);
 }
 export async function markEntityReasoned(t, entityId) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    db.prepare(`UPDATE entities SET last_reasoned_at = datetime('now') WHERE id = ?`).run(entityId);
+    return getStorage().entities.markEntityReasoned(t, entityId);
 }
-// ─── Pin operations ───────────────────────────────────────────────────────────
 export async function pinEntity(t, entityId, pinned = true) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    db.prepare('UPDATE entities SET is_pinned = ? WHERE id = ?').run(pinned ? 1 : 0, entityId);
+    return getStorage().entities.pinEntity(t, entityId, pinned);
 }
 export async function listPinned(t, type) {
-    ensureSchema(t);
-    const db = getDb(t, 'entityGraph');
-    let sql = 'SELECT * FROM entities WHERE is_pinned = 1';
-    const params = [];
-    if (type) {
-        sql += ' AND type = ?';
-        params.push(type);
-    }
-    sql += ' ORDER BY last_seen DESC';
-    return db.prepare(sql).all(...params).map(rowToEntity);
+    return getStorage().entities.listPinned(t, type);
 }
 //# sourceMappingURL=entity-graph.js.map