hippo-memory 0.5.0 → 0.6.0

package/dist/store.js

@@ -1,12 +1,17 @@
 /**
  * Storage layer for Hippo.
- * Reads/writes MemoryEntry as markdown + YAML frontmatter.
- * Maintains a JSON index for fast lookups.
+ *
+ * SQLite is the source of truth.
+ * Markdown + JSON files remain as human-readable compatibility mirrors.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { Layer } from './memory.js';
 import { dumpFrontmatter, parseFrontmatter } from './yaml.js';
+import { openHippoDb, closeHippoDb, getMeta, setMeta, isFtsAvailable, pruneConsolidationRuns, getHippoDbPath, } from './db.js';
+const INDEX_VERSION = 2;
+const MEMORY_SELECT_COLUMNS = `id, created, last_retrieved, retrieval_count, strength, half_life_days, layer, tags_json, emotional_valence, schema_fit, source, outcome_score, conflicts_with_json, pinned, confidence, content`;
+const DEFAULT_SEARCH_CANDIDATE_LIMIT = 200;
 function layerDir(root, layer) {
     return path.join(root, layer);
 }
@@ -17,6 +22,17 @@ export function isInitialized(hippoRoot) {
     return fs.existsSync(hippoRoot);
 }
 export function initStore(hippoRoot) {
+    ensureMirrorDirectories(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        bootstrapLegacyStore(db, hippoRoot);
+        syncMirrorFiles(hippoRoot, db);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+function ensureMirrorDirectories(hippoRoot) {
     const dirs = [
         hippoRoot,
         path.join(hippoRoot, 'buffer'),
@@ -25,37 +41,9 @@ export function initStore(hippoRoot) {
         path.join(hippoRoot, 'conflicts'),
     ];
     for (const dir of dirs) {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-    }
-    const indexPath = path.join(hippoRoot, 'index.json');
-    if (!fs.existsSync(indexPath)) {
-        const empty = { version: 1, entries: {}, last_retrieval_ids: [] };
-        fs.writeFileSync(indexPath, JSON.stringify(empty, null, 2), 'utf8');
-    }
-    const statsPath = path.join(hippoRoot, 'stats.json');
-    if (!fs.existsSync(statsPath)) {
-        const stats = {
-            total_remembered: 0,
-            total_recalled: 0,
-            total_forgotten: 0,
-            consolidation_runs: [],
-        };
-        fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2), 'utf8');
+        fs.mkdirSync(dir, { recursive: true });
     }
 }
-export function loadIndex(hippoRoot) {
-    const indexPath = path.join(hippoRoot, 'index.json');
-    if (!fs.existsSync(indexPath)) {
-        return { version: 1, entries: {}, last_retrieval_ids: [] };
-    }
-    return JSON.parse(fs.readFileSync(indexPath, 'utf8'));
-}
-export function saveIndex(hippoRoot, index) {
-    const indexPath = path.join(hippoRoot, 'index.json');
-    fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), 'utf8');
-}
 /**
  * Serialize a MemoryEntry to markdown with YAML frontmatter.
  */
@@ -94,153 +82,726 @@ export function deserializeEntry(raw) {
         strength: Number(data['strength'] ?? 1.0),
         half_life_days: Number(data['half_life_days'] ?? 7),
         layer: data['layer'],
-        tags: data['tags'] ?? [],
+        tags: normalizeStringArray(data['tags']),
         emotional_valence: data['emotional_valence'] ?? 'neutral',
         schema_fit: Number(data['schema_fit'] ?? 0.5),
         source: String(data['source'] ?? 'cli'),
-        outcome_score: data['outcome_score'] === null ? null : Number(data['outcome_score']),
-        conflicts_with: data['conflicts_with'] ?? [],
+        outcome_score: data['outcome_score'] === null || data['outcome_score'] === undefined ? null : Number(data['outcome_score']),
+        conflicts_with: normalizeStringArray(data['conflicts_with']),
         pinned: Boolean(data['pinned'] ?? false),
         confidence: data['confidence'] ?? 'observed',
         content: content.trim(),
     };
 }
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => String(item));
+}
+function rowToEntry(row) {
+    return {
+        id: row.id,
+        created: row.created,
+        last_retrieved: row.last_retrieved,
+        retrieval_count: Number(row.retrieval_count ?? 0),
+        strength: Number(row.strength ?? 1),
+        half_life_days: Number(row.half_life_days ?? 7),
+        layer: row.layer,
+        tags: parseJsonArray(row.tags_json),
+        emotional_valence: row.emotional_valence ?? 'neutral',
+        schema_fit: Number(row.schema_fit ?? 0.5),
+        source: row.source ?? 'cli',
+        outcome_score: row.outcome_score === null || row.outcome_score === undefined ? null : Number(row.outcome_score),
+        conflicts_with: parseJsonArray(row.conflicts_with_json),
+        pinned: Boolean(row.pinned),
+        confidence: row.confidence ?? 'observed',
+        content: row.content,
+    };
+}
+function parseJsonArray(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.map((item) => String(item)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function rowToTaskSnapshot(row) {
+    return {
+        id: Number(row.id),
+        task: row.task,
+        summary: row.summary,
+        next_step: row.next_step,
+        status: row.status,
+        source: row.source,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function rowToMemoryConflict(row) {
+    return {
+        id: Number(row.id),
+        memory_a_id: row.memory_a_id,
+        memory_b_id: row.memory_b_id,
+        reason: row.reason,
+        score: Number(row.score ?? 0),
+        status: row.status,
+        detected_at: row.detected_at,
+        updated_at: row.updated_at,
+    };
+}
+function writeActiveTaskMirror(hippoRoot, snapshot) {
+    const filePath = path.join(hippoRoot, 'buffer', 'active-task.md');
+    const fm = dumpFrontmatter({
+        id: snapshot.id,
+        task: snapshot.task,
+        status: snapshot.status,
+        source: snapshot.source,
+        created_at: snapshot.created_at,
+        updated_at: snapshot.updated_at,
+        next_step: snapshot.next_step,
+    });
+    const body = [
+        `# Active Task Snapshot`,
+        '',
+        `## Summary`,
+        snapshot.summary,
+        '',
+        `## Next step`,
+        snapshot.next_step,
+        '',
+        `## Task`,
+        snapshot.task,
+        '',
+    ].join('\n');
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${fm}\n\n${body}`, 'utf8');
+}
+function removeActiveTaskMirror(hippoRoot) {
+    const filePath = path.join(hippoRoot, 'buffer', 'active-task.md');
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+function writeConflictMirrors(hippoRoot, conflicts) {
+    const conflictDir = path.join(hippoRoot, 'conflicts');
+    fs.mkdirSync(conflictDir, { recursive: true });
+    const keep = new Set();
+    for (const conflict of conflicts) {
+        const filename = `conflict_${conflict.id}.md`;
+        keep.add(filename);
+        const fm = dumpFrontmatter({
+            id: conflict.id,
+            memory_a_id: conflict.memory_a_id,
+            memory_b_id: conflict.memory_b_id,
+            reason: conflict.reason,
+            score: Math.round(conflict.score * 10000) / 10000,
+            status: conflict.status,
+            detected_at: conflict.detected_at,
+            updated_at: conflict.updated_at,
+        });
+        const body = [
+            '# Memory Conflict',
+            '',
+            `- Memory A: ${conflict.memory_a_id}`,
+            `- Memory B: ${conflict.memory_b_id}`,
+            `- Reason: ${conflict.reason}`,
+            `- Score: ${conflict.score.toFixed(3)}`,
+            `- Status: ${conflict.status}`,
+            '',
+        ].join('\n');
+        fs.writeFileSync(path.join(conflictDir, filename), `${fm}\n\n${body}`, 'utf8');
+    }
+    for (const existing of fs.readdirSync(conflictDir)) {
+        if (existing === '.gitkeep')
+            continue;
+        if (!keep.has(existing)) {
+            fs.unlinkSync(path.join(conflictDir, existing));
+        }
+    }
+}
+function canonicalConflictPair(aId, bId) {
+    return aId < bId
+        ? { memory_a_id: aId, memory_b_id: bId }
+        : { memory_a_id: bId, memory_b_id: aId };
+}
+function tokenizeSearchQuery(query) {
+    return query
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter((term) => term.length > 1);
+}
+function loadSearchRows(db, query, limit) {
+    const terms = Array.from(new Set(tokenizeSearchQuery(query)));
+    if (terms.length === 0) {
+        return db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories ORDER BY created ASC, id ASC`).all();
+    }
+    if (isFtsAvailable(db)) {
+        try {
+            const ftsQuery = terms.map((term) => `${term.replace(/"/g, '""')}*`).join(' OR ');
+            const rows = db.prepare(`
+        SELECT ${MEMORY_SELECT_COLUMNS}
+        FROM memories m
+        JOIN memories_fts f ON f.id = m.id
+        WHERE memories_fts MATCH ?
+        ORDER BY bm25(memories_fts), m.updated_at DESC
+        LIMIT ?
+      `).all(ftsQuery, limit);
+            if (rows.length > 0)
+                return rows;
+        }
+        catch {
+            // Fall back to LIKE matching below.
+        }
+    }
+    const where = terms.map(() => `(LOWER(content) LIKE ? OR LOWER(tags_json) LIKE ?)`).join(' OR ');
+    const params = terms.flatMap((term) => {
+        const like = `%${term}%`;
+        return [like, like];
+    });
+    const rows = db.prepare(`
+    SELECT ${MEMORY_SELECT_COLUMNS}
+    FROM memories
+    WHERE ${where}
+    ORDER BY updated_at DESC, created DESC
+    LIMIT ?
+  `).all(...params, limit);
+    if (rows.length > 0)
+        return rows;
+    return db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories ORDER BY created ASC, id ASC`).all();
+}
+function writeMarkdownMirror(hippoRoot, entry) {
+    removeEntryMirrors(hippoRoot, entry.id);
+    const dir = layerDir(hippoRoot, entry.layer);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${entry.id}.md`), serializeEntry(entry), 'utf8');
+}
+function removeEntryMirrors(hippoRoot, id) {
+    for (const layer of [Layer.Buffer, Layer.Episodic, Layer.Semantic]) {
+        const file = path.join(layerDir(hippoRoot, layer), `${id}.md`);
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+        }
+    }
+}
+function bootstrapLegacyStore(db, hippoRoot) {
+    const countRow = db.prepare(`SELECT COUNT(*) AS count FROM memories`).get();
+    const memoryCount = Number(countRow?.count ?? 0);
+    if (memoryCount > 0)
+        return;
+    const legacyEntries = loadLegacyEntriesFromMarkdown(hippoRoot);
+    if (legacyEntries.length === 0)
+        return;
+    db.exec('BEGIN');
+    try {
+        for (const entry of legacyEntries) {
+            upsertEntryRow(db, entry);
+        }
+        const legacyIndex = loadLegacyIndexFile(hippoRoot);
+        setMeta(db, 'last_retrieval_ids', JSON.stringify(legacyIndex.last_retrieval_ids ?? []));
+        const legacyStats = loadLegacyStatsFile(hippoRoot);
+        setMeta(db, 'total_remembered', String(Number(legacyStats.total_remembered ?? 0)));
+        setMeta(db, 'total_recalled', String(Number(legacyStats.total_recalled ?? 0)));
+        setMeta(db, 'total_forgotten', String(Number(legacyStats.total_forgotten ?? 0)));
+        const runs = Array.isArray(legacyStats.consolidation_runs) ? legacyStats.consolidation_runs : [];
+        const insertRun = db.prepare(`INSERT INTO consolidation_runs(timestamp, decayed, merged, removed) VALUES (?, ?, ?, ?)`);
+        for (const run of runs) {
+            if (!run || typeof run !== 'object')
+                continue;
+            const row = run;
+            insertRun.run(String(row.timestamp ?? new Date().toISOString()), Number(row.decayed ?? 0), Number(row.merged ?? 0), Number(row.removed ?? 0));
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+function loadLegacyEntriesFromMarkdown(hippoRoot) {
+    const entries = [];
+    for (const layer of [Layer.Buffer, Layer.Episodic, Layer.Semantic]) {
+        const dir = layerDir(hippoRoot, layer);
+        if (!fs.existsSync(dir))
+            continue;
+        for (const file of fs.readdirSync(dir)) {
+            if (!file.endsWith('.md'))
+                continue;
+            const raw = fs.readFileSync(path.join(dir, file), 'utf8');
+            const entry = deserializeEntry(raw);
+            if (entry)
+                entries.push(entry);
+        }
+    }
+    return entries;
+}
+function loadLegacyIndexFile(hippoRoot) {
+    const indexPath = path.join(hippoRoot, 'index.json');
+    if (!fs.existsSync(indexPath)) {
+        return { version: 1, entries: {}, last_retrieval_ids: [] };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+    }
+    catch {
+        return { version: 1, entries: {}, last_retrieval_ids: [] };
+    }
+}
+function loadLegacyStatsFile(hippoRoot) {
+    const statsPath = path.join(hippoRoot, 'stats.json');
+    if (!fs.existsSync(statsPath)) {
+        return {
+            total_remembered: 0,
+            total_recalled: 0,
+            total_forgotten: 0,
+            consolidation_runs: [],
+        };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(statsPath, 'utf8'));
+    }
+    catch {
+        return {
+            total_remembered: 0,
+            total_recalled: 0,
+            total_forgotten: 0,
+            consolidation_runs: [],
+        };
+    }
+}
+function upsertEntryRow(db, entry) {
+    db.prepare(`
+    INSERT INTO memories(
+      id, created, last_retrieved, retrieval_count, strength, half_life_days, layer,
+      tags_json, emotional_valence, schema_fit, source, outcome_score,
+      conflicts_with_json, pinned, confidence, content, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(id) DO UPDATE SET
+      created = excluded.created,
+      last_retrieved = excluded.last_retrieved,
+      retrieval_count = excluded.retrieval_count,
+      strength = excluded.strength,
+      half_life_days = excluded.half_life_days,
+      layer = excluded.layer,
+      tags_json = excluded.tags_json,
+      emotional_valence = excluded.emotional_valence,
+      schema_fit = excluded.schema_fit,
+      source = excluded.source,
+      outcome_score = excluded.outcome_score,
+      conflicts_with_json = excluded.conflicts_with_json,
+      pinned = excluded.pinned,
+      confidence = excluded.confidence,
+      content = excluded.content,
+      updated_at = datetime('now')
+  `).run(entry.id, entry.created, entry.last_retrieved, entry.retrieval_count, entry.strength, entry.half_life_days, entry.layer, JSON.stringify(entry.tags ?? []), entry.emotional_valence, entry.schema_fit, entry.source, entry.outcome_score, JSON.stringify(entry.conflicts_with ?? []), entry.pinned ? 1 : 0, entry.confidence, entry.content);
+    syncFtsRow(db, entry);
+}
+function syncFtsRow(db, entry) {
+    if (!isFtsAvailable(db))
+        return;
+    try {
+        db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(entry.id);
+        db.prepare(`INSERT INTO memories_fts(id, content, tags) VALUES (?, ?, ?)`).run(entry.id, entry.content, entry.tags.join(' '));
+    }
+    catch {
+        // Best effort only. SQLite store is still authoritative even if FTS is unavailable.
+    }
+}
+function deleteFtsRow(db, id) {
+    if (!isFtsAvailable(db))
+        return;
+    try {
+        db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(id);
+    }
+    catch {
+        // Best effort.
+    }
+}
+function buildIndexFromDb(db) {
+    const rows = db.prepare(`SELECT id, created, last_retrieved, strength, layer, tags_json, pinned FROM memories ORDER BY created ASC, id ASC`).all();
+    const entries = {};
+    for (const row of rows) {
+        const layer = row.layer;
+        entries[row.id] = {
+            id: row.id,
+            file: path.join(layer, `${row.id}.md`),
+            layer,
+            strength: Number(row.strength ?? 0),
+            tags: parseJsonArray(row.tags_json),
+            created: row.created,
+            last_retrieved: row.last_retrieved,
+            pinned: Boolean(row.pinned),
+        };
+    }
+    return {
+        version: INDEX_VERSION,
+        entries,
+        last_retrieval_ids: parseJsonArray(getMeta(db, 'last_retrieval_ids', '[]')),
+    };
+}
+function buildStatsFromDb(db) {
+    const runs = db.prepare(`SELECT timestamp, decayed, merged, removed FROM consolidation_runs ORDER BY timestamp ASC, id ASC`).all();
+    return {
+        total_remembered: Number(getMeta(db, 'total_remembered', '0')),
+        total_recalled: Number(getMeta(db, 'total_recalled', '0')),
+        total_forgotten: Number(getMeta(db, 'total_forgotten', '0')),
+        consolidation_runs: runs,
+    };
+}
+function writeIndexMirror(hippoRoot, index) {
+    fs.writeFileSync(path.join(hippoRoot, 'index.json'), JSON.stringify(index, null, 2), 'utf8');
+}
+function writeStatsMirror(hippoRoot, stats) {
+    fs.writeFileSync(path.join(hippoRoot, 'stats.json'), JSON.stringify(stats, null, 2), 'utf8');
+}
+function syncMirrorFiles(hippoRoot, db) {
+    const entries = db.prepare(`SELECT id, created, last_retrieved, retrieval_count, strength, half_life_days, layer, tags_json, emotional_valence, schema_fit, source, outcome_score, conflicts_with_json, pinned, confidence, content FROM memories ORDER BY created ASC, id ASC`).all();
+    for (const entry of entries.map(rowToEntry)) {
+        writeMarkdownMirror(hippoRoot, entry);
+    }
+    const conflicts = db.prepare(`
+    SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
+    FROM memory_conflicts
+    WHERE status = 'open'
+    ORDER BY updated_at DESC, id DESC
+  `).all();
+    writeConflictMirrors(hippoRoot, conflicts.map(rowToMemoryConflict));
+    writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+    writeStatsMirror(hippoRoot, buildStatsFromDb(db));
+}
+/**
+ * Load the current derived index from SQLite and refresh the mirror file.
+ */
+export function loadIndex(hippoRoot) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const index = buildIndexFromDb(db);
+        writeIndexMirror(hippoRoot, index);
+        return index;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Persist mutable index metadata. Entry rows themselves are derived from SQLite.
+ */
+export function saveIndex(hippoRoot, index) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        setMeta(db, 'last_retrieval_ids', JSON.stringify(index.last_retrieval_ids ?? []));
+        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
 /**
- * Write a memory entry to disk and update the index.
+ * Write a memory entry to SQLite and refresh compatibility mirrors.
  */
 export function writeEntry(hippoRoot, entry) {
-    const dir = layerDir(hippoRoot, entry.layer);
-    const filename = `${entry.id}.md`;
-    const filepath = path.join(dir, filename);
-    fs.writeFileSync(filepath, serializeEntry(entry), 'utf8');
-    // Update index
-    const index = loadIndex(hippoRoot);
-    index.entries[entry.id] = {
-        id: entry.id,
-        file: path.join(entry.layer, filename),
-        layer: entry.layer,
-        strength: entry.strength,
-        tags: entry.tags,
-        created: entry.created,
-        last_retrieved: entry.last_retrieved,
-        pinned: entry.pinned,
-    };
-    saveIndex(hippoRoot, index);
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        upsertEntryRow(db, entry);
+        writeMarkdownMirror(hippoRoot, entry);
+        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+    }
+    finally {
+        closeHippoDb(db);
+    }
 }
 /**
  * Read a memory entry by ID.
  */
 export function readEntry(hippoRoot, id) {
-    const index = loadIndex(hippoRoot);
-    const ref = index.entries[id];
-    if (!ref)
-        return null;
-    const filepath = path.join(hippoRoot, ref.file);
-    if (!fs.existsSync(filepath))
-        return null;
-    const raw = fs.readFileSync(filepath, 'utf8');
-    return deserializeEntry(raw);
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = db.prepare(`SELECT id, created, last_retrieved, retrieval_count, strength, half_life_days, layer, tags_json, emotional_valence, schema_fit, source, outcome_score, conflicts_with_json, pinned, confidence, content FROM memories WHERE id = ?`).get(id);
+        return row ? rowToEntry(row) : null;
+    }
+    finally {
+        closeHippoDb(db);
+    }
 }
 /**
- * Delete an entry from disk and index.
+ * Delete an entry from SQLite and mirrors.
  */
 export function deleteEntry(hippoRoot, id) {
-    const index = loadIndex(hippoRoot);
-    const ref = index.entries[id];
-    if (!ref)
-        return false;
-    const filepath = path.join(hippoRoot, ref.file);
-    if (fs.existsSync(filepath)) {
-        fs.unlinkSync(filepath);
-    }
-    delete index.entries[id];
-    saveIndex(hippoRoot, index);
-    return true;
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const exists = db.prepare(`SELECT id FROM memories WHERE id = ?`).get(id);
+        if (!exists?.id)
+            return false;
+        db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+        deleteFtsRow(db, id);
+        removeEntryMirrors(hippoRoot, id);
+        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+        return true;
+    }
+    finally {
+        closeHippoDb(db);
+    }
 }
 /**
- * Load all entries from disk (for search, consolidation, etc.)
+ * Load all entries from SQLite.
  */
 export function loadAllEntries(hippoRoot) {
-    const index = loadIndex(hippoRoot);
-    const entries = [];
-    for (const ref of Object.values(index.entries)) {
-        const filepath = path.join(hippoRoot, ref.file);
-        if (!fs.existsSync(filepath))
-            continue;
-        const raw = fs.readFileSync(filepath, 'utf8');
-        const entry = deserializeEntry(raw);
-        if (entry)
-            entries.push(entry);
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories ORDER BY created ASC, id ASC`).all();
+        return rows.map(rowToEntry);
+    }
+    finally {
+        closeHippoDb(db);
     }
-    return entries;
 }
 /**
- * Rebuild the index from all markdown files on disk.
+ * Load likely search candidates directly from SQLite.
+ * Uses FTS5 when available, falls back to LIKE matching, then full-store fallback.
  */
-export function rebuildIndex(hippoRoot) {
-    const index = { version: 1, entries: {}, last_retrieval_ids: [] };
-    const layers = [Layer.Buffer, Layer.Episodic, Layer.Semantic];
-    for (const layer of layers) {
-        const dir = layerDir(hippoRoot, layer);
-        if (!fs.existsSync(dir))
-            continue;
-        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
-        for (const file of files) {
-            const filepath = path.join(dir, file);
-            const raw = fs.readFileSync(filepath, 'utf8');
-            const entry = deserializeEntry(raw);
-            if (!entry)
-                continue;
-            index.entries[entry.id] = {
-                id: entry.id,
-                file: path.join(layer, file),
-                layer: entry.layer,
-                strength: entry.strength,
-                tags: entry.tags,
-                created: entry.created,
-                last_retrieved: entry.last_retrieved,
-                pinned: entry.pinned,
-            };
-        }
+export function loadSearchEntries(hippoRoot, query, limit = DEFAULT_SEARCH_CANDIDATE_LIMIT) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        return loadSearchRows(db, query, limit).map(rowToEntry);
+    }
+    finally {
+        closeHippoDb(db);
     }
-    saveIndex(hippoRoot, index);
-    return index;
 }
 /**
- * Update stats file.
+ * Rebuild mirrors from SQLite, importing any legacy markdown files not already present.
  */
+export function rebuildIndex(hippoRoot) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const existingIds = new Set(db.prepare(`SELECT id FROM memories`).all().map((row) => row.id));
+        const legacyEntries = loadLegacyEntriesFromMarkdown(hippoRoot).filter((entry) => !existingIds.has(entry.id));
+        if (legacyEntries.length > 0) {
+            for (const entry of legacyEntries) {
+                upsertEntryRow(db, entry);
+            }
+        }
+        syncMirrorFiles(hippoRoot, db);
+        return buildIndexFromDb(db);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
 export function updateStats(hippoRoot, delta) {
-    const statsPath = path.join(hippoRoot, 'stats.json');
-    let stats = { total_remembered: 0, total_recalled: 0, total_forgotten: 0, consolidation_runs: [] };
-    if (fs.existsSync(statsPath)) {
-        stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
-    }
-    if (delta.remembered)
-        stats.total_remembered += delta.remembered;
-    if (delta.recalled)
-        stats.total_recalled += delta.recalled;
-    if (delta.forgotten)
-        stats.total_forgotten += delta.forgotten;
-    fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2), 'utf8');
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const remembered = Number(getMeta(db, 'total_remembered', '0')) + Number(delta.remembered ?? 0);
+        const recalled = Number(getMeta(db, 'total_recalled', '0')) + Number(delta.recalled ?? 0);
+        const forgotten = Number(getMeta(db, 'total_forgotten', '0')) + Number(delta.forgotten ?? 0);
+        setMeta(db, 'total_remembered', String(remembered));
+        setMeta(db, 'total_recalled', String(recalled));
+        setMeta(db, 'total_forgotten', String(forgotten));
+        writeStatsMirror(hippoRoot, buildStatsFromDb(db));
+    }
+    finally {
+        closeHippoDb(db);
+    }
 }
 export function loadStats(hippoRoot) {
-    const statsPath = path.join(hippoRoot, 'stats.json');
-    if (!fs.existsSync(statsPath))
-        return {};
-    return JSON.parse(fs.readFileSync(statsPath, 'utf8'));
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const stats = buildStatsFromDb(db);
+        writeStatsMirror(hippoRoot, stats);
+        return stats;
+    }
+    finally {
+        closeHippoDb(db);
+    }
 }
 export function appendConsolidationRun(hippoRoot, run) {
-    const statsPath = path.join(hippoRoot, 'stats.json');
-    const stats = fs.existsSync(statsPath)
-        ? JSON.parse(fs.readFileSync(statsPath, 'utf8'))
-        : { consolidation_runs: [] };
-    if (!Array.isArray(stats.consolidation_runs))
-        stats.consolidation_runs = [];
-    stats.consolidation_runs.push(run);
-    // Keep last 50 runs
-    if (stats.consolidation_runs.length > 50) {
-        stats.consolidation_runs = stats.consolidation_runs.slice(-50);
-    }
-    fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2), 'utf8');
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        db.prepare(`INSERT INTO consolidation_runs(timestamp, decayed, merged, removed) VALUES (?, ?, ?, ?)`).run(run.timestamp, run.decayed, run.merged, run.removed);
+        pruneConsolidationRuns(db, 50);
+        writeStatsMirror(hippoRoot, buildStatsFromDb(db));
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function saveActiveTaskSnapshot(hippoRoot, snapshot) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    const now = new Date().toISOString();
+    try {
+        db.exec('BEGIN');
+        db.prepare(`UPDATE task_snapshots SET status = 'superseded', updated_at = ? WHERE status = 'active'`).run(now);
+        const result = db.prepare(`
+      INSERT INTO task_snapshots(task, summary, next_step, status, source, created_at, updated_at)
+      VALUES (?, ?, ?, 'active', ?, ?, ?)
+    `).run(snapshot.task, snapshot.summary, snapshot.next_step, snapshot.source ?? 'cli', now, now);
+        db.exec('COMMIT');
+        const id = Number(result.lastInsertRowid ?? 0);
+        const row = db.prepare(`
+      SELECT id, task, summary, next_step, status, source, created_at, updated_at
+      FROM task_snapshots
+      WHERE id = ?
+    `).get(id);
+        if (!row) {
+            throw new Error('Failed to reload saved active task snapshot');
+        }
+        const loaded = rowToTaskSnapshot(row);
+        writeActiveTaskMirror(hippoRoot, loaded);
+        return loaded;
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch {
+            // Ignore nested rollback failures.
+        }
+        throw error;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function loadActiveTaskSnapshot(hippoRoot) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = db.prepare(`
+      SELECT id, task, summary, next_step, status, source, created_at, updated_at
+      FROM task_snapshots
+      WHERE status = 'active'
+      ORDER BY updated_at DESC, id DESC
+      LIMIT 1
+    `).get();
+        if (!row) {
+            removeActiveTaskMirror(hippoRoot);
+            return null;
+        }
+        const loaded = rowToTaskSnapshot(row);
+        writeActiveTaskMirror(hippoRoot, loaded);
+        return loaded;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function clearActiveTaskSnapshot(hippoRoot, clearedStatus = 'cleared') {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    const now = new Date().toISOString();
+    try {
+        const active = db.prepare(`SELECT id FROM task_snapshots WHERE status = 'active' ORDER BY updated_at DESC, id DESC LIMIT 1`).get();
+        if (!active?.id) {
+            removeActiveTaskMirror(hippoRoot);
+            return false;
+        }
+        db.prepare(`UPDATE task_snapshots SET status = ?, updated_at = ? WHERE id = ?`).run(clearedStatus, now, active.id);
+        removeActiveTaskMirror(hippoRoot);
+        return true;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function listMemoryConflicts(hippoRoot, status = 'open') {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const rows = db.prepare(`
+      SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
+      FROM memory_conflicts
+      WHERE status = ?
+      ORDER BY updated_at DESC, id DESC
+    `).all(status);
+        return rows.map(rowToMemoryConflict);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function replaceDetectedConflicts(hippoRoot, detected, detectedAt = new Date().toISOString()) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        db.exec('BEGIN');
+        const canonicalDetected = detected.map((conflict) => ({
+            ...canonicalConflictPair(conflict.memory_a_id, conflict.memory_b_id),
+            reason: conflict.reason,
+            score: conflict.score,
+        }));
+        const detectedKeys = new Set(canonicalDetected.map((conflict) => `${conflict.memory_a_id}::${conflict.memory_b_id}`));
+        const openRows = db.prepare(`
+      SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
+      FROM memory_conflicts
+      WHERE status = 'open'
+    `).all();
+        for (const row of openRows) {
+            const key = `${row.memory_a_id}::${row.memory_b_id}`;
+            if (!detectedKeys.has(key)) {
+                db.prepare(`UPDATE memory_conflicts SET status = 'resolved', updated_at = ? WHERE id = ?`).run(detectedAt, row.id);
+            }
+        }
+        for (const conflict of canonicalDetected) {
+            db.prepare(`
+        INSERT INTO memory_conflicts(memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at)
+        VALUES (?, ?, ?, ?, 'open', ?, ?)
+        ON CONFLICT(memory_a_id, memory_b_id) DO UPDATE SET
+          reason = excluded.reason,
+          score = excluded.score,
+          status = 'open',
+          updated_at = excluded.updated_at
+      `).run(conflict.memory_a_id, conflict.memory_b_id, conflict.reason, conflict.score, detectedAt, detectedAt);
+        }
+        const openConflicts = db.prepare(`
+      SELECT memory_a_id, memory_b_id
+      FROM memory_conflicts
+      WHERE status = 'open'
+    `).all();
+        const refMap = new Map();
+        for (const row of openConflicts) {
+            if (!refMap.has(row.memory_a_id))
+                refMap.set(row.memory_a_id, new Set());
+            if (!refMap.has(row.memory_b_id))
+                refMap.set(row.memory_b_id, new Set());
+            refMap.get(row.memory_a_id).add(row.memory_b_id);
+            refMap.get(row.memory_b_id).add(row.memory_a_id);
+        }
+        const memoryRows = db.prepare(`SELECT id FROM memories`).all();
+        for (const memory of memoryRows) {
+            const refs = Array.from(refMap.get(memory.id) ?? []).sort();
+            db.prepare(`UPDATE memories SET conflicts_with_json = ?, updated_at = datetime('now') WHERE id = ?`).run(JSON.stringify(refs), memory.id);
+        }
+        db.exec('COMMIT');
+        syncMirrorFiles(hippoRoot, db);
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch {
+            // Ignore nested rollback failures.
+        }
+        throw error;
+    }
+    finally {
+        closeHippoDb(db);
+    }
 }
+export { getHippoDbPath };
 //# sourceMappingURL=store.js.map