hippo-memory 0.36.0 → 0.37.0

package/dist/src/store.js

@@ -0,0 +1,1390 @@
+/**
+ * Storage layer for Hippo.
+ *
+ * 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';
+import { rowToSessionHandoff } from './handoff.js';
+import { tokenize } from './search.js';
+import { appendAuditEvent } from './audit.js';
+import { resolveTenantId } from './tenant.js';
+/**
+ * Emit an audit event for a mutation against `db`. Wrapped so a broken audit
+ * log can never crash the surrounding mutation — the SQLite store is still the
+ * source of truth and audit failures are diagnosable from the missing rows.
+ */
+function audit(db, op, targetId, metadata, actor = 'cli', tenantId) {
+    try {
+        appendAuditEvent(db, {
+            tenantId: tenantId ?? resolveTenantId({}),
+            actor,
+            op,
+            targetId,
+            metadata,
+        });
+    }
+    catch {
+        // Audit must never crash a mutation. Failures here mean the audit_log
+        // table is broken; the mutation has already succeeded.
+    }
+}
+const INDEX_VERSION = 3;
+const MEMORY_SELECT_COLUMNS = `id, created, last_retrieved, retrieval_count, strength, half_life_days, layer, tags_json, emotional_valence, schema_fit, source, outcome_score, outcome_positive, outcome_negative, conflicts_with_json, pinned, confidence, content, parents_json, starred, trace_outcome, source_session_id, valid_from, superseded_by, extracted_from, dag_level, dag_parent_id, kind, scope, owner, artifact_ref, tenant_id`;
+const DEFAULT_SEARCH_CANDIDATE_LIMIT = 200;
+function layerDir(root, layer) {
+    return path.join(root, layer);
+}
+export function getHippoRoot(cwd = process.cwd()) {
+    return path.join(cwd, '.hippo');
+}
+export function isInitialized(hippoRoot) {
+    // A bare .hippo directory is not enough — autoInstallHooks /
+    // setupDailySchedule can create it without ever calling initStore,
+    // leaving a partial directory (integrations/, logs/, runs/) with no
+    // hippo.db. Returning true in that state caused `hippo init` to skip
+    // initStore and `hippo recall` to silently fall back to an empty store
+    // (incident 2026-04-26: ingest_direct.py against a bare .hippo).
+    // Treat the store as initialized only if hippo.db actually exists.
+    return fs.existsSync(path.join(hippoRoot, 'hippo.db'));
+}
+export function initStore(hippoRoot) {
+    ensureMirrorDirectories(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const bootstrapped = bootstrapLegacyStore(db, hippoRoot);
+        if (bootstrapped) {
+            syncMirrorFiles(hippoRoot, db);
+        }
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+function ensureMirrorDirectories(hippoRoot) {
+    const dirs = [
+        hippoRoot,
+        path.join(hippoRoot, 'buffer'),
+        path.join(hippoRoot, 'episodic'),
+        path.join(hippoRoot, 'semantic'),
+        path.join(hippoRoot, 'conflicts'),
+    ];
+    for (const dir of dirs) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * Serialize a MemoryEntry to markdown with YAML frontmatter.
+ */
+export function serializeEntry(entry) {
+    const frontmatter = {
+        id: entry.id,
+        created: entry.created,
+        last_retrieved: entry.last_retrieved,
+        retrieval_count: entry.retrieval_count,
+        strength: Math.round(entry.strength * 10000) / 10000,
+        half_life_days: entry.half_life_days,
+        layer: entry.layer,
+        tags: entry.tags,
+        emotional_valence: entry.emotional_valence,
+        schema_fit: entry.schema_fit,
+        source: entry.source,
+        outcome_score: entry.outcome_score,
+        outcome_positive: entry.outcome_positive,
+        outcome_negative: entry.outcome_negative,
+        conflicts_with: entry.conflicts_with,
+        pinned: entry.pinned,
+        confidence: entry.confidence ?? 'observed',
+        parents: entry.parents ?? [],
+        starred: entry.starred ?? false,
+        trace_outcome: entry.trace_outcome ?? null,
+        source_session_id: entry.source_session_id ?? null,
+        kind: entry.kind ?? 'distilled',
+        scope: entry.scope ?? null,
+        owner: entry.owner ?? null,
+        artifact_ref: entry.artifact_ref ?? null,
+    };
+    // Emit tenant_id only when not 'default' to keep diffs clean for the dominant
+    // single-tenant case (mirrors the plan's task 7 guidance).
+    const tenantId = entry.tenantId ?? 'default';
+    if (tenantId !== 'default') {
+        frontmatter['tenant_id'] = tenantId;
+    }
+    const fm = dumpFrontmatter(frontmatter);
+    return `${fm}\n\n${entry.content}\n`;
+}
+/**
+ * Deserialize a markdown file to a MemoryEntry.
+ */
+export function deserializeEntry(raw) {
+    const { data, content } = parseFrontmatter(raw);
+    if (!data['id'] || !data['layer'])
+        return null;
+    return {
+        id: String(data['id']),
+        created: String(data['created'] ?? new Date().toISOString()),
+        last_retrieved: String(data['last_retrieved'] ?? new Date().toISOString()),
+        retrieval_count: Number(data['retrieval_count'] ?? 0),
+        strength: Number(data['strength'] ?? 1.0),
+        half_life_days: Number(data['half_life_days'] ?? 7),
+        layer: data['layer'],
+        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 || data['outcome_score'] === undefined ? null : Number(data['outcome_score']),
+        outcome_positive: Number(data['outcome_positive'] ?? 0),
+        outcome_negative: Number(data['outcome_negative'] ?? 0),
+        conflicts_with: normalizeStringArray(data['conflicts_with']),
+        pinned: Boolean(data['pinned'] ?? false),
+        confidence: data['confidence'] ?? 'observed',
+        content: content.trim(),
+        parents: normalizeStringArray(data['parents']),
+        starred: Boolean(data['starred'] ?? false),
+        trace_outcome: data['trace_outcome'] ?? null,
+        source_session_id: data['source_session_id'] === null || data['source_session_id'] === undefined
+            ? null
+            : String(data['source_session_id']),
+        valid_from: data['valid_from'] ? String(data['valid_from']) : String(data['created'] ?? new Date().toISOString()),
+        superseded_by: data['superseded_by'] === null || data['superseded_by'] === undefined
+            ? null
+            : String(data['superseded_by']),
+        extracted_from: data['extracted_from'] ?? null,
+        dag_level: Number(data['dag_level'] ?? 0),
+        dag_parent_id: data['dag_parent_id'] ?? null,
+        kind: (data['kind'] ?? 'distilled'),
+        scope: data['scope'] === null || data['scope'] === undefined ? null : String(data['scope']),
+        owner: data['owner'] === null || data['owner'] === undefined ? null : String(data['owner']),
+        artifact_ref: data['artifact_ref'] === null || data['artifact_ref'] === undefined ? null : String(data['artifact_ref']),
+        tenantId: data['tenant_id'] === null || data['tenant_id'] === undefined ? 'default' : String(data['tenant_id']),
+    };
+}
+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),
+        outcome_positive: Number(row.outcome_positive ?? 0),
+        outcome_negative: Number(row.outcome_negative ?? 0),
+        conflicts_with: parseJsonArray(row.conflicts_with_json),
+        pinned: Boolean(row.pinned),
+        confidence: row.confidence ?? 'observed',
+        content: row.content,
+        parents: parseJsonArray(row.parents_json),
+        starred: Boolean(row.starred),
+        trace_outcome: row.trace_outcome ?? null,
+        source_session_id: row.source_session_id ?? null,
+        valid_from: row.valid_from ?? row.created,
+        superseded_by: row.superseded_by ?? null,
+        extracted_from: row.extracted_from ?? null,
+        dag_level: Number(row.dag_level ?? 0),
+        dag_parent_id: row.dag_parent_id ?? null,
+        kind: (row.kind ?? 'distilled'),
+        scope: row.scope ?? null,
+        owner: row.owner ?? null,
+        artifact_ref: row.artifact_ref ?? null,
+        tenantId: row.tenant_id ?? 'default',
+    };
+}
+function parseJsonArray(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.map((item) => String(item)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseJsonObject(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    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,
+        session_id: row.session_id ?? null,
+        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 rowToSessionEvent(row) {
+    return {
+        id: Number(row.id),
+        session_id: row.session_id,
+        task: row.task ?? null,
+        event_type: row.event_type,
+        content: row.content,
+        source: row.source,
+        metadata: parseJsonObject(row.metadata_json),
+        created_at: row.created_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,
+        session_id: snapshot.session_id,
+        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,
+        '',
+    ];
+    if (snapshot.session_id) {
+        body.push(`## Session`, snapshot.session_id, '');
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${fm}\n\n${body.join('\n')}`, 'utf8');
+}
+function removeActiveTaskMirror(hippoRoot) {
+    const filePath = path.join(hippoRoot, 'buffer', 'active-task.md');
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+function writeRecentSessionMirror(hippoRoot, events) {
+    const filePath = path.join(hippoRoot, 'buffer', 'recent-session.md');
+    if (events.length === 0) {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+        return;
+    }
+    const latest = events[events.length - 1];
+    const fm = dumpFrontmatter({
+        session_id: latest.session_id,
+        task: latest.task,
+        event_count: events.length,
+        updated_at: latest.created_at,
+    });
+    const lines = [
+        '# Recent Session Trail',
+        '',
+        `- Session: ${latest.session_id}`,
+        `- Task: ${latest.task ?? 'n/a'}`,
+        `- Updated: ${latest.created_at}`,
+        '',
+        '## Events',
+        '',
+    ];
+    for (const event of events) {
+        lines.push(`- [${event.created_at}] (${event.event_type}) ${event.content}`);
+    }
+    lines.push('');
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${fm}\n\n${lines.join('\n')}`, 'utf8');
+}
+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 loadSearchRows(db, query, limit, tenantId) {
+    // tenantId undefined = no tenant filter (legacy callers / cross-deployment
+    // helpers). tenantId set = strict tenant isolation, leveraging the composite
+    // idx_memories_tenant_created (leading column tenant_id, O(log n) lookup).
+    const tenantPredicate = tenantId !== undefined ? ` AND m.tenant_id = ?` : '';
+    const tenantPredicateNoAlias = tenantId !== undefined ? ` AND tenant_id = ?` : '';
+    const tenantOnlyPredicate = tenantId !== undefined ? ` WHERE tenant_id = ?` : '';
+    const tenantParams = tenantId !== undefined ? [tenantId] : [];
+    const terms = Array.from(new Set(tokenize(query)));
+    if (terms.length === 0) {
+        const sql = `SELECT ${MEMORY_SELECT_COLUMNS} FROM memories${tenantOnlyPredicate} ORDER BY created ASC, id ASC`;
+        return db.prepare(sql).all(...tenantParams);
+    }
+    if (isFtsAvailable(db)) {
+        try {
+            const ftsQuery = terms.map((t) => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+            // memories_fts virtual table has no tenant_id column; filter via the
+            // joined memories row (cheap with idx_memories_tenant_created leading
+            // on tenant_id).
+            const rows = db.prepare(`
+        SELECT ${MEMORY_SELECT_COLUMNS}
+        FROM memories m
+        JOIN memories_fts f ON f.id = m.id
+        WHERE memories_fts MATCH ?${tenantPredicate}
+        ORDER BY bm25(memories_fts), m.updated_at DESC
+        LIMIT ?
+      `).all(ftsQuery, ...tenantParams, limit);
+            if (rows.length > 0)
+                return rows;
+        }
+        catch {
+            // Fall back to LIKE matching below.
+        }
+    }
+    const escapeLike = (term) => term.replace(/[%_\\]/g, '\\$&');
+    const where = terms.map(() => `(LOWER(content) LIKE ? ESCAPE '\\' OR LOWER(tags_json) LIKE ? ESCAPE '\\')`).join(' OR ');
+    const params = terms.flatMap((term) => {
+        const like = `%${escapeLike(term)}%`;
+        return [like, like];
+    });
+    const rows = db.prepare(`
+    SELECT ${MEMORY_SELECT_COLUMNS}
+    FROM memories
+    WHERE (${where})${tenantPredicateNoAlias}
+    ORDER BY updated_at DESC, created DESC
+    LIMIT ?
+  `).all(...params, ...tenantParams, limit);
+    if (rows.length > 0)
+        return rows;
+    const fallback = `SELECT ${MEMORY_SELECT_COLUMNS} FROM memories${tenantOnlyPredicate} ORDER BY created ASC, id ASC`;
+    return db.prepare(fallback).all(...tenantParams);
+}
+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');
+}
+export 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 false;
+    const legacyEntries = loadLegacyEntriesFromMarkdown(hippoRoot);
+    if (legacyEntries.length === 0)
+        return false;
+    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;
+    }
+    return true;
+}
+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,
+      outcome_positive, outcome_negative,
+      conflicts_with_json, pinned, confidence, content,
+      parents_json, starred,
+      trace_outcome, source_session_id,
+      valid_from, superseded_by,
+      extracted_from,
+      dag_level, dag_parent_id,
+      kind, scope, owner, artifact_ref,
+      tenant_id,
+      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,
+      outcome_positive = excluded.outcome_positive,
+      outcome_negative = excluded.outcome_negative,
+      conflicts_with_json = excluded.conflicts_with_json,
+      pinned = excluded.pinned,
+      confidence = excluded.confidence,
+      content = excluded.content,
+      parents_json = excluded.parents_json,
+      starred = excluded.starred,
+      trace_outcome = excluded.trace_outcome,
+      source_session_id = excluded.source_session_id,
+      valid_from = excluded.valid_from,
+      superseded_by = excluded.superseded_by,
+      extracted_from = excluded.extracted_from,
+      dag_level = excluded.dag_level,
+      dag_parent_id = excluded.dag_parent_id,
+      kind = excluded.kind,
+      scope = excluded.scope,
+      owner = excluded.owner,
+      artifact_ref = excluded.artifact_ref,
+      tenant_id = excluded.tenant_id,
+      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, entry.outcome_positive ?? 0, entry.outcome_negative ?? 0, JSON.stringify(entry.conflicts_with ?? []), entry.pinned ? 1 : 0, entry.confidence, entry.content, JSON.stringify(entry.parents ?? []), entry.starred ? 1 : 0, entry.trace_outcome ?? null, entry.source_session_id ?? null, entry.valid_from ?? entry.created, entry.superseded_by ?? null, entry.extracted_from ?? null, entry.dag_level ?? 0, entry.dag_parent_id ?? null, entry.kind ?? 'distilled', entry.scope ?? null, entry.owner ?? null, entry.artifact_ref ?? null, entry.tenantId ?? 'default');
+    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 ${MEMORY_SELECT_COLUMNS} 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 SQLite and refresh compatibility mirrors.
+ *
+ * `opts.actor` defaults to 'cli' so unauthenticated direct-CLI callers still
+ * get the right audit attribution. The HTTP server (A1) and api.* layer pass
+ * the resolved actor (`api_key:<key_id>` / `localhost:cli`) so audit events
+ * land with one row per write, no double-emit.
+ *
+ * `opts.afterWrite` is invoked inside the same SAVEPOINT as the memories
+ * INSERT (mirrors archiveRawMemory's shape in raw-archive.ts). On callback
+ * throw, the SAVEPOINT rolls back — the memory row never lands, and the
+ * filesystem mirrors / audit emit never run. Used by E1.3+ connectors to
+ * stamp idempotency rows atomically with the memory write.
+ */
+export function writeEntry(hippoRoot, entry, opts) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        // SAVEPOINT (not BEGIN) so this nests safely inside any outer transaction
+        // a future caller might hold. SQLite refuses BEGIN within a transaction;
+        // SAVEPOINT is the only way to scope rollback without disturbing outers.
+        db.exec('SAVEPOINT write_entry');
+        try {
+            upsertEntryRow(db, entry);
+            if (opts?.afterWrite) {
+                opts.afterWrite(db, entry.id);
+            }
+            db.exec('RELEASE SAVEPOINT write_entry');
+        }
+        catch (e) {
+            try {
+                db.exec('ROLLBACK TO SAVEPOINT write_entry');
+                db.exec('RELEASE SAVEPOINT write_entry');
+            }
+            catch {
+                // Ignore rollback failures — the throw below is what matters.
+            }
+            throw e;
+        }
+        // Filesystem mirrors and audit emit run only after the SAVEPOINT releases,
+        // so a rolled-back write leaves no orphan markdown or index entries.
+        writeMarkdownMirror(hippoRoot, entry);
+        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+        audit(db, 'remember', entry.id, {
+            kind: entry.kind ?? 'distilled',
+            scope: entry.scope ?? null,
+        }, opts?.actor ?? 'cli', entry.tenantId);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Read a memory entry by ID.
+ *
+ * When `tenantId` is provided, the read is scoped to that tenant (cross-tenant
+ * lookups return null). When omitted, no tenant filter is applied — preserves
+ * legacy single-tenant callers and the writeEntry/readEntry round-trip.
+ */
+export function readEntry(hippoRoot, id, tenantId) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = tenantId !== undefined
+            ? db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id = ? AND tenant_id = ?`).get(id, tenantId)
+            : db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id = ?`).get(id);
+        return row ? rowToEntry(row) : null;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Delete an entry from SQLite and mirrors.
+ *
+ * `opts.actor` defaults to 'cli'. The api.* layer threads `ctx.actor` so HTTP
+ * callers land with `api_key:<key_id>` in the audit log without a duplicate
+ * emit from the api wrapper.
+ */
+export function deleteEntry(hippoRoot, id, opts) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = db
+            .prepare(`SELECT id, tenant_id FROM memories WHERE id = ?`)
+            .get(id);
+        if (!row?.id)
+            return false;
+        db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+        deleteFtsRow(db, id);
+        removeEntryMirrors(hippoRoot, id);
+        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+        audit(db, 'forget', id, undefined, opts?.actor ?? 'cli', row.tenant_id);
+        return true;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Batch-write and batch-delete entries in a single transaction.
+ * Used by consolidation to avoid N open/close cycles.
+ */
+export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds) {
+    if (toWrite.length === 0 && toDeleteIds.length === 0)
+        return;
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        db.exec('BEGIN');
+        for (const entry of toWrite) {
+            upsertEntryRow(db, entry);
+        }
+        for (const id of toDeleteIds) {
+            db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+            deleteFtsRow(db, id);
+        }
+        db.exec('COMMIT');
+        // Sync mirrors once after all DB writes
+        for (const entry of toWrite) {
+            writeMarkdownMirror(hippoRoot, entry);
+        }
+        for (const id of toDeleteIds) {
+            removeEntryMirrors(hippoRoot, id);
+        }
+        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* ignore */ }
+        throw error;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Load all entries from SQLite.
+ *
+ * When `tenantId` is provided, results are scoped to that tenant. Omitting it
+ * yields all rows (legacy behavior used by consolidate/autolearn etc.). Recall
+ * paths that surface results to a user MUST pass a resolved tenant.
+ */
+export function loadAllEntries(hippoRoot, tenantId) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const rows = tenantId !== undefined
+            ? db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE tenant_id = ? ORDER BY created ASC, id ASC`).all(tenantId)
+            : db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories ORDER BY created ASC, id ASC`).all();
+        return rows.map(rowToEntry);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Load likely search candidates directly from SQLite.
+ * Uses FTS5 when available, falls back to LIKE matching, then full-store fallback.
+ *
+ * When `tenantId` is provided, every SELECT (FTS join, LIKE, fallback) filters
+ * by tenant_id. Cross-tenant memories never surface. Omitted = no filter.
+ */
+export function loadSearchEntries(hippoRoot, query, limit = DEFAULT_SEARCH_CANDIDATE_LIMIT, tenantId) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        return loadSearchRows(db, query, limit, tenantId).map(rowToEntry);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * 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) {
+            db.exec('BEGIN');
+            try {
+                for (const entry of legacyEntries) {
+                    upsertEntryRow(db, entry);
+                }
+                db.exec('COMMIT');
+            }
+            catch (err) {
+                try {
+                    db.exec('ROLLBACK');
+                }
+                catch { /* ignore if no active txn */ }
+                throw err;
+            }
+        }
+        syncMirrorFiles(hippoRoot, db);
+        return buildIndexFromDb(db);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function updateStats(hippoRoot, delta) {
+    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) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const stats = buildStatsFromDb(db);
+        writeStatsMirror(hippoRoot, stats);
+        return stats;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function appendConsolidationRun(hippoRoot, run) {
+    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);
+    }
+}
+/**
+ * Load the session decay context from the store.
+ * Uses consolidation_runs timestamps to compute session intervals.
+ */
+export function loadSessionDecayContext(hippoRoot) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        // Get recent consolidation timestamps (last 20)
+        const rows = db.prepare(`SELECT timestamp FROM consolidation_runs ORDER BY timestamp DESC, id DESC LIMIT 20`).all();
+        const sleepCount = Number(getMeta(db, 'sleep_count', '0')) || rows.length;
+        if (rows.length < 2) {
+            return { sleepCount, avgSessionIntervalDays: 0 };
+        }
+        // Compute average interval between consecutive sessions
+        const timestamps = rows.map((r) => new Date(r.timestamp).getTime()).reverse();
+        let totalInterval = 0;
+        for (let i = 1; i < timestamps.length; i++) {
+            totalInterval += timestamps[i] - timestamps[i - 1];
+        }
+        const avgMs = totalInterval / (timestamps.length - 1);
+        const avgDays = avgMs / (1000 * 60 * 60 * 24);
+        return { sleepCount, avgSessionIntervalDays: Math.max(0, avgDays) };
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Increment the sleep counter. Called after each consolidation run.
+ */
+export function incrementSleepCount(hippoRoot) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const current = Number(getMeta(db, 'sleep_count', '0')) || 0;
+        setMeta(db, 'sleep_count', String(current + 1));
+    }
+    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, session_id, created_at, updated_at)
+      VALUES (?, ?, ?, 'active', ?, ?, ?, ?)
+    `).run(snapshot.task, snapshot.summary, snapshot.next_step, snapshot.source ?? 'cli', snapshot.session_id ?? null, now, now);
+        db.exec('COMMIT');
+        const id = Number(result.lastInsertRowid ?? 0);
+        const row = db.prepare(`
+      SELECT id, task, summary, next_step, status, source, session_id, 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, session_id, 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 appendSessionEvent(hippoRoot, event) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    const now = new Date().toISOString();
+    try {
+        const result = db.prepare(`
+      INSERT INTO session_events(session_id, task, event_type, content, source, metadata_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(event.session_id, event.task ?? null, event.event_type, event.content, event.source ?? 'cli', JSON.stringify(event.metadata ?? {}), now);
+        const id = Number(result.lastInsertRowid ?? 0);
+        const row = db.prepare(`
+      SELECT id, session_id, task, event_type, content, source, metadata_json, created_at
+      FROM session_events
+      WHERE id = ?
+    `).get(id);
+        if (!row) {
+            throw new Error('Failed to reload saved session event');
+        }
+        const loaded = rowToSessionEvent(row);
+        // Query recent events inline using the already-open db handle
+        // (avoids opening a second connection via listSessionEvents)
+        const recentRows = db.prepare(`
+      SELECT id, session_id, task, event_type, content, source, metadata_json, created_at
+      FROM session_events
+      WHERE session_id = ?
+      ORDER BY created_at DESC, id DESC
+      LIMIT ?
+    `).all(loaded.session_id, 20);
+        const recent = recentRows.map(rowToSessionEvent).reverse();
+        writeRecentSessionMirror(hippoRoot, recent);
+        return loaded;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export function listSessionEvents(hippoRoot, options = {}) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const clauses = [];
+        const params = [];
+        if (options.session_id) {
+            clauses.push('session_id = ?');
+            params.push(options.session_id);
+        }
+        if (options.task) {
+            clauses.push('task = ?');
+            params.push(options.task);
+        }
+        const limit = Math.max(1, Math.trunc(options.limit ?? 8));
+        params.push(limit);
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`
+      SELECT id, session_id, task, event_type, content, source, metadata_json, created_at
+      FROM session_events
+      ${where}
+      ORDER BY created_at DESC, id DESC
+      LIMIT ?
+    `).all(...params);
+        return rows.map(rowToSessionEvent).reverse();
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Return session_ids with a `session_complete` event newer than `sinceMs`.
+ * Used by the sleep auto-promotion pass to bound scanning to a fixed window.
+ */
+export function findPromotableSessions(hippoRoot, sinceMs) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const rows = db.prepare(`
+      SELECT DISTINCT session_id FROM session_events
+      WHERE event_type = 'session_complete' AND created_at >= ?
+    `).all(new Date(sinceMs).toISOString());
+        return rows;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Idempotency guard — true if a trace-layer memory with this source_session_id
+ * already exists.
+ */
+export function traceExistsForSession(hippoRoot, session_id) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = db.prepare(`
+      SELECT 1 FROM memories
+      WHERE source_session_id = ? AND layer = 'trace'
+      LIMIT 1
+    `).get(session_id);
+        return !!row;
+    }
+    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);
+    }
+}
+/**
+ * Resolve a conflict by keeping one memory and weakening the other.
+ * Sets conflict status to 'resolved' and halves the loser's half-life.
+ * If --forget is used, the loser is deleted entirely.
+ *
+ * Returns the resolved conflict, or null if not found.
+ */
+export function resolveConflict(hippoRoot, conflictId, keepId, forgetLoser = false) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = db.prepare(`
+      SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
+      FROM memory_conflicts WHERE id = ?
+    `).get(conflictId);
+        if (!row)
+            return null;
+        const conflict = rowToMemoryConflict(row);
+        if (conflict.status !== 'open')
+            return null;
+        const loserId = keepId === conflict.memory_a_id
+            ? conflict.memory_b_id
+            : keepId === conflict.memory_b_id
+                ? conflict.memory_a_id
+                : null;
+        if (!loserId)
+            return null;
+        db.exec('BEGIN');
+        // Mark conflict as resolved
+        db.prepare(`UPDATE memory_conflicts SET status = 'resolved', updated_at = datetime('now') WHERE id = ?`)
+            .run(conflictId);
+        if (forgetLoser) {
+            // Delete the losing memory
+            db.prepare(`DELETE FROM memories WHERE id = ?`).run(loserId);
+        }
+        else {
+            // Halve the loser's half-life (weakens it over time)
+            db.prepare(`UPDATE memories SET half_life_days = MAX(1, half_life_days / 2), updated_at = datetime('now') WHERE id = ?`)
+                .run(loserId);
+        }
+        // Clean up conflicts_with references
+        const keepRow = db.prepare(`SELECT conflicts_with_json FROM memories WHERE id = ?`).get(keepId);
+        if (keepRow) {
+            const refs = JSON.parse(keepRow.conflicts_with_json || '[]');
+            const cleaned = refs.filter((r) => r !== loserId);
+            db.prepare(`UPDATE memories SET conflicts_with_json = ?, updated_at = datetime('now') WHERE id = ?`)
+                .run(JSON.stringify(cleaned), keepId);
+        }
+        if (!forgetLoser) {
+            const loserRow = db.prepare(`SELECT conflicts_with_json FROM memories WHERE id = ?`).get(loserId);
+            if (loserRow) {
+                const refs = JSON.parse(loserRow.conflicts_with_json || '[]');
+                const cleaned = refs.filter((r) => r !== keepId);
+                db.prepare(`UPDATE memories SET conflicts_with_json = ?, updated_at = datetime('now') WHERE id = ?`)
+                    .run(JSON.stringify(cleaned), loserId);
+            }
+        }
+        db.exec('COMMIT');
+        syncMirrorFiles(hippoRoot, db);
+        return { conflict: { ...conflict, status: 'resolved' }, loserId };
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* ignore */ }
+        throw error;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Save a session handoff record. Returns the persisted handoff.
+ */
+export function saveSessionHandoff(hippoRoot, handoff) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    const now = new Date().toISOString();
+    try {
+        const result = db.prepare(`
+      INSERT INTO session_handoffs(session_id, repo_root, task_id, summary, next_action, artifacts_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(handoff.sessionId, handoff.repoRoot ?? null, handoff.taskId ?? null, handoff.summary, handoff.nextAction ?? null, JSON.stringify(handoff.artifacts ?? []), now);
+        const id = Number(result.lastInsertRowid ?? 0);
+        const row = db.prepare(`
+      SELECT id, session_id, repo_root, task_id, summary, next_action, artifacts_json, created_at
+      FROM session_handoffs
+      WHERE id = ?
+    `).get(id);
+        if (!row) {
+            throw new Error('Failed to reload saved session handoff');
+        }
+        return rowToSessionHandoff(row);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Load the most recent handoff, optionally filtered by session ID.
+ */
+export function loadLatestHandoff(hippoRoot, sessionId) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        let row;
+        if (sessionId) {
+            row = db.prepare(`
+        SELECT id, session_id, repo_root, task_id, summary, next_action, artifacts_json, created_at
+        FROM session_handoffs
+        WHERE session_id = ?
+        ORDER BY created_at DESC, id DESC
+        LIMIT 1
+      `).get(sessionId);
+        }
+        else {
+            row = db.prepare(`
+        SELECT id, session_id, repo_root, task_id, summary, next_action, artifacts_json, created_at
+        FROM session_handoffs
+        ORDER BY created_at DESC, id DESC
+        LIMIT 1
+      `).get();
+        }
+        return row ? rowToSessionHandoff(row) : null;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/**
+ * Load a specific handoff by its row ID.
+ */
+export function loadHandoffById(hippoRoot, id) {
+    initStore(hippoRoot);
+    const db = openHippoDb(hippoRoot);
+    try {
+        const row = db.prepare(`
+      SELECT id, session_id, repo_root, task_id, summary, next_action, artifacts_json, created_at
+      FROM session_handoffs
+      WHERE id = ?
+    `).get(id);
+        return row ? rowToSessionHandoff(row) : null;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+export { getHippoDbPath };
+//# sourceMappingURL=store.js.map