@aman_asmuei/amem 0.19.0 → 0.20.0

package/dist/database.js

@@ -1,831 +0,0 @@
-import Database from "better-sqlite3";
-import { randomUUID, createHash } from "node:crypto";
-function rowToMemory(row) {
-    return {
-        id: row.id,
-        content: row.content,
-        type: row.type,
-        tags: JSON.parse(row.tags),
-        confidence: row.confidence,
-        accessCount: row.access_count,
-        createdAt: row.created_at,
-        lastAccessed: row.last_accessed,
-        source: row.source,
-        embedding: row.embedding
-            ? new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4)
-            : null,
-        scope: row.scope,
-        validFrom: row.valid_from ?? row.created_at,
-        validUntil: row.valid_until ?? null,
-        tier: (row.tier ?? 'archival'),
-        utilityScore: row.utility_score ?? 0,
-    };
-}
-function rowToSummary(row) {
-    return {
-        id: row.id,
-        sessionId: row.session_id,
-        summary: row.summary,
-        keyDecisions: JSON.parse(row.key_decisions),
-        keyCorrections: JSON.parse(row.key_corrections),
-        memoriesExtracted: row.memories_extracted,
-        project: row.project,
-        createdAt: row.created_at,
-    };
-}
-function rowToRelation(r) {
-    return {
-        id: r.id,
-        fromId: r.from_id,
-        toId: r.to_id,
-        relationshipType: r.relationship_type,
-        strength: r.strength,
-        createdAt: r.created_at,
-        validFrom: r.valid_from ?? null,
-        validUntil: r.valid_until ?? null,
-    };
-}
-export function createDatabase(dbPath) {
-    const db = new Database(dbPath);
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
-    db.pragma("busy_timeout = 5000"); // Wait up to 5s for lock — enables multi-process safety
-    // Expose transaction support for atomic multi-step operations
-    const runTransaction = db.transaction((fn) => fn());
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id TEXT PRIMARY KEY,
-      content TEXT NOT NULL,
-      type TEXT NOT NULL,
-      tags TEXT NOT NULL DEFAULT '[]',
-      confidence REAL NOT NULL DEFAULT 1.0,
-      access_count INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      last_accessed INTEGER NOT NULL,
-      source TEXT NOT NULL,
-      embedding BLOB,
-      scope TEXT NOT NULL DEFAULT 'global'
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
-    CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);
-    CREATE INDEX IF NOT EXISTS idx_memories_confidence ON memories(confidence);
-
-    -- Lossless raw conversation log (append-only)
-    CREATE TABLE IF NOT EXISTS conversation_log (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      role TEXT NOT NULL CHECK(role IN ('user','assistant','system')),
-      content TEXT NOT NULL,
-      timestamp INTEGER NOT NULL,
-      project TEXT NOT NULL DEFAULT 'global',
-      metadata TEXT NOT NULL DEFAULT '{}'
-    );
-    CREATE INDEX IF NOT EXISTS idx_log_session ON conversation_log(session_id);
-    CREATE INDEX IF NOT EXISTS idx_log_timestamp ON conversation_log(timestamp);
-    CREATE INDEX IF NOT EXISTS idx_log_project ON conversation_log(project);
-
-    -- FTS for full-text search on memories
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      id UNINDEXED,
-      content,
-      tags,
-      content='memories',
-      content_rowid='rowid'
-    );
-
-    -- FTS for full-text search on conversation log
-    CREATE VIRTUAL TABLE IF NOT EXISTS log_fts USING fts5(
-      id UNINDEXED,
-      content,
-      content='conversation_log',
-      content_rowid='rowid'
-    );
-
-    -- Memory version history
-    CREATE TABLE IF NOT EXISTS memory_versions (
-      version_id TEXT PRIMARY KEY,
-      memory_id TEXT NOT NULL,
-      content TEXT NOT NULL,
-      confidence REAL NOT NULL,
-      edited_at INTEGER NOT NULL,
-      reason TEXT NOT NULL DEFAULT 'manual edit',
-      FOREIGN KEY(memory_id) REFERENCES memories(id) ON DELETE CASCADE
-    );
-    CREATE INDEX IF NOT EXISTS idx_versions_memory_id ON memory_versions(memory_id);
-
-    -- Knowledge graph: relations between memories
-    CREATE TABLE IF NOT EXISTS memory_relations (
-      id TEXT PRIMARY KEY,
-      from_id TEXT NOT NULL,
-      to_id TEXT NOT NULL,
-      relationship_type TEXT NOT NULL,
-      strength REAL NOT NULL DEFAULT 0.8,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY(from_id) REFERENCES memories(id) ON DELETE CASCADE,
-      FOREIGN KEY(to_id) REFERENCES memories(id) ON DELETE CASCADE,
-      UNIQUE(from_id, to_id, relationship_type)
-    );
-    CREATE INDEX IF NOT EXISTS idx_relations_from ON memory_relations(from_id);
-    CREATE INDEX IF NOT EXISTS idx_relations_to ON memory_relations(to_id);
-
-    -- Reminders
-    CREATE TABLE IF NOT EXISTS reminders (
-      id TEXT PRIMARY KEY,
-      content TEXT NOT NULL,
-      due_at INTEGER,
-      completed INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      scope TEXT NOT NULL DEFAULT 'global'
-    );
-    CREATE INDEX IF NOT EXISTS idx_reminders_due ON reminders(due_at);
-    CREATE INDEX IF NOT EXISTS idx_reminders_completed ON reminders(completed);
-
-    -- Session summaries
-    CREATE TABLE IF NOT EXISTS session_summaries (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      summary TEXT NOT NULL,
-      key_decisions TEXT NOT NULL DEFAULT '[]',
-      key_corrections TEXT NOT NULL DEFAULT '[]',
-      memories_extracted INTEGER NOT NULL DEFAULT 0,
-      project TEXT NOT NULL DEFAULT 'global',
-      created_at INTEGER NOT NULL,
-      UNIQUE(session_id)
-    );
-    CREATE INDEX IF NOT EXISTS idx_summaries_session ON session_summaries(session_id);
-    CREATE INDEX IF NOT EXISTS idx_summaries_project ON session_summaries(project);
-  `);
-    // ── Schema migrations ──────────────────────────────────
-    // Versioned migration system — each migration runs exactly once.
-    // New migrations MUST be appended to the end of this array.
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      version INTEGER PRIMARY KEY,
-      name TEXT NOT NULL,
-      applied_at INTEGER NOT NULL
-    )
-  `);
-    const appliedVersions = new Set(db.prepare("SELECT version FROM schema_migrations").all().map(r => r.version));
-    const hasColumn = (table, column) => {
-        const cols = db.pragma(`table_info(${table})`);
-        return cols.some(c => c.name === column);
-    };
-    const migrations = [
-        {
-            version: 1,
-            name: "add_scope_column",
-            up: () => {
-                if (!hasColumn("memories", "scope")) {
-                    db.exec(`ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'global'`);
-                }
-                db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)`);
-            },
-        },
-        {
-            version: 2,
-            name: "add_content_hash",
-            up: () => {
-                if (!hasColumn("memories", "content_hash")) {
-                    db.exec(`ALTER TABLE memories ADD COLUMN content_hash TEXT`);
-                    const allRows = db.prepare("SELECT id, content FROM memories").all();
-                    const updateHash = db.prepare("UPDATE memories SET content_hash = ? WHERE id = ?");
-                    for (const row of allRows) {
-                        updateHash.run(createHash("sha256").update(row.content).digest("hex").slice(0, 16), row.id);
-                    }
-                }
-                db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash)`);
-            },
-        },
-        {
-            version: 3,
-            name: "add_temporal_validity_and_tiers",
-            up: () => {
-                if (!hasColumn("memories", "valid_from")) {
-                    db.exec(`ALTER TABLE memories ADD COLUMN valid_from INTEGER`);
-                    db.exec(`ALTER TABLE memories ADD COLUMN valid_until INTEGER`);
-                    db.exec(`ALTER TABLE memories ADD COLUMN tier TEXT NOT NULL DEFAULT 'archival'`);
-                    db.exec(`UPDATE memories SET valid_from = created_at WHERE valid_from IS NULL`);
-                }
-                db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_valid_until ON memories(valid_until)`);
-                db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`);
-            },
-        },
-        {
-            version: 4,
-            name: "add_temporal_relations",
-            up: () => {
-                if (!hasColumn("memory_relations", "valid_from")) {
-                    db.exec(`ALTER TABLE memory_relations ADD COLUMN valid_from INTEGER`);
-                    db.exec(`ALTER TABLE memory_relations ADD COLUMN valid_until INTEGER`);
-                    db.exec(`UPDATE memory_relations SET valid_from = created_at WHERE valid_from IS NULL`);
-                }
-            },
-        },
-        {
-            version: 5,
-            name: "add_self_evolving_loop_support",
-            up: () => {
-                if (!hasColumn("memories", "utility_score")) {
-                    db.exec("ALTER TABLE memories ADD COLUMN utility_score INTEGER NOT NULL DEFAULT 0");
-                }
-                db.exec("CREATE TABLE IF NOT EXISTS synthesis_lineage (synthesis_id TEXT NOT NULL, source_id TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY(synthesis_id, source_id), FOREIGN KEY(synthesis_id) REFERENCES memories(id) ON DELETE CASCADE, FOREIGN KEY(source_id) REFERENCES memories(id) ON DELETE CASCADE)");
-                db.exec("CREATE INDEX IF NOT EXISTS idx_lineage_synthesis ON synthesis_lineage(synthesis_id)");
-                db.exec("CREATE INDEX IF NOT EXISTS idx_lineage_source ON synthesis_lineage(source_id)");
-                db.exec("CREATE TABLE IF NOT EXISTS knowledge_gaps (id TEXT PRIMARY KEY, query_pattern TEXT NOT NULL, hit_count INTEGER NOT NULL DEFAULT 1, avg_confidence REAL NOT NULL DEFAULT 0, avg_results INTEGER NOT NULL DEFAULT 0, first_seen INTEGER NOT NULL, last_seen INTEGER NOT NULL, resolved INTEGER NOT NULL DEFAULT 0)");
-                db.exec("CREATE INDEX IF NOT EXISTS idx_gaps_resolved ON knowledge_gaps(resolved)");
-                db.exec("CREATE INDEX IF NOT EXISTS idx_gaps_hit_count ON knowledge_gaps(hit_count)");
-                db.exec("CREATE TABLE IF NOT EXISTS reflection_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at INTEGER NOT NULL)");
-            },
-        },
-    ];
-    const insertMigration = db.prepare("INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, ?)");
-    for (const m of migrations) {
-        if (appliedVersions.has(m.version))
-            continue;
-        m.up();
-        insertMigration.run(m.version, m.name, Date.now());
-    }
-    const stmts = {
-        insert: db.prepare(`
-      INSERT INTO memories (id, content, type, tags, confidence, access_count, created_at, last_accessed, source, embedding, scope, content_hash, valid_from, valid_until, tier)
-      VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `),
-        getById: db.prepare(`SELECT * FROM memories WHERE id = ?`),
-        searchByType: db.prepare(`SELECT * FROM memories WHERE type = ? ORDER BY last_accessed DESC`),
-        searchByTag: db.prepare(`SELECT * FROM memories WHERE tags LIKE ? ORDER BY last_accessed DESC`),
-        getAllWithEmbeddings: db.prepare(`SELECT * FROM memories WHERE embedding IS NOT NULL`),
-        getRecentWithEmbeddings: db.prepare(`SELECT * FROM memories WHERE embedding IS NOT NULL ORDER BY last_accessed DESC LIMIT ?`),
-        getAll: db.prepare(`SELECT * FROM memories ORDER BY last_accessed DESC`),
-        updateConfidence: db.prepare(`
-      UPDATE memories SET confidence = ?, access_count = access_count + 1, last_accessed = ? WHERE id = ?
-    `),
-        updateEmbedding: db.prepare(`UPDATE memories SET embedding = ? WHERE id = ?`),
-        touchAccess: db.prepare(`
-      UPDATE memories SET access_count = access_count + 1, last_accessed = ? WHERE id = ?
-    `),
-        deleteMemory: db.prepare(`DELETE FROM memories WHERE id = ?`),
-        countAll: db.prepare(`SELECT COUNT(*) as count FROM memories`),
-        countHighConf: db.prepare(`SELECT COUNT(*) as count FROM memories WHERE confidence >= 0.8`),
-        countMedConf: db.prepare(`SELECT COUNT(*) as count FROM memories WHERE confidence >= 0.5 AND confidence < 0.8`),
-        countLowConf: db.prepare(`SELECT COUNT(*) as count FROM memories WHERE confidence < 0.5`),
-        countWithEmbeddings: db.prepare(`SELECT COUNT(*) as count FROM memories WHERE embedding IS NOT NULL`),
-        countByType: db.prepare(`SELECT type, COUNT(*) as count FROM memories GROUP BY type`),
-        listTables: db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name`),
-        searchByScope: db.prepare(`SELECT * FROM memories WHERE scope = ? ORDER BY last_accessed DESC`),
-        getAllForProject: db.prepare(`SELECT * FROM memories WHERE scope = 'global' OR scope = ? ORDER BY last_accessed DESC`),
-        updateContent: db.prepare(`UPDATE memories SET content = ?, last_accessed = ? WHERE id = ?`),
-        updateType: db.prepare(`UPDATE memories SET type = ?, last_accessed = ? WHERE id = ?`),
-        updateTags: db.prepare(`UPDATE memories SET tags = ?, last_accessed = ? WHERE id = ?`),
-        getByDateRange: db.prepare(`SELECT * FROM memories WHERE created_at BETWEEN ? AND ? ORDER BY created_at DESC`),
-        getSince: db.prepare(`SELECT * FROM memories WHERE created_at >= ? ORDER BY created_at DESC`),
-        // Log
-        insertLog: db.prepare(`
-      INSERT INTO conversation_log (id, session_id, role, content, timestamp, project, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `),
-        getLogBySession: db.prepare(`SELECT * FROM conversation_log WHERE session_id = ? ORDER BY timestamp ASC`),
-        getRecentLog: db.prepare(`SELECT * FROM conversation_log ORDER BY timestamp DESC LIMIT ?`),
-        getRecentLogByProject: db.prepare(`SELECT * FROM conversation_log WHERE project = ? ORDER BY timestamp DESC LIMIT ?`),
-        deleteLogBefore: db.prepare(`DELETE FROM conversation_log WHERE timestamp < ?`),
-        countLog: db.prepare(`SELECT COUNT(*) as count FROM conversation_log`),
-        // Versions
-        insertVersion: db.prepare(`
-      INSERT INTO memory_versions (version_id, memory_id, content, confidence, edited_at, reason)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `),
-        getVersions: db.prepare(`SELECT * FROM memory_versions WHERE memory_id = ? ORDER BY edited_at DESC`),
-        // Relations
-        insertRelation: db.prepare(`
-      INSERT OR REPLACE INTO memory_relations (id, from_id, to_id, relationship_type, strength, created_at, valid_from)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `),
-        getRelationsFrom: db.prepare(`SELECT * FROM memory_relations WHERE from_id = ?`),
-        getRelationsTo: db.prepare(`SELECT * FROM memory_relations WHERE to_id = ?`),
-        deleteRelation: db.prepare(`DELETE FROM memory_relations WHERE id = ?`),
-        // Reminders
-        insertReminder: db.prepare("INSERT INTO reminders (id, content, due_at, completed, created_at, scope) VALUES (?, ?, ?, 0, ?, ?)"),
-        listReminders: db.prepare("SELECT * FROM reminders WHERE completed = 0 ORDER BY due_at ASC NULLS LAST"),
-        listAllReminders: db.prepare("SELECT * FROM reminders ORDER BY due_at ASC NULLS LAST"),
-        listRemindersByScope: db.prepare("SELECT * FROM reminders WHERE completed = 0 AND (scope = 'global' OR scope = ?) ORDER BY due_at ASC NULLS LAST"),
-        listAllRemindersByScope: db.prepare("SELECT * FROM reminders WHERE (scope = 'global' OR scope = ?) ORDER BY due_at ASC NULLS LAST"),
-        completeReminder: db.prepare("UPDATE reminders SET completed = 1 WHERE id = ?"),
-        // Content hash dedup
-        findByContentHash: db.prepare("SELECT * FROM memories WHERE content_hash = ? LIMIT 1"),
-        // ID resolution via SQL prefix match (avoids full table scan)
-        resolveIdPrefix: db.prepare("SELECT id FROM memories WHERE id LIKE ? LIMIT 2"),
-        resolveReminderIdPrefix: db.prepare("SELECT id FROM reminders WHERE id LIKE ? LIMIT 2"),
-        // Batch relation loading
-        getAllRelations: db.prepare("SELECT * FROM memory_relations ORDER BY created_at DESC"),
-        // Temporal validity
-        getValidMemories: db.prepare(`SELECT * FROM memories WHERE (valid_until IS NULL OR valid_until > ?) ORDER BY last_accessed DESC`),
-        expireMemory: db.prepare(`UPDATE memories SET valid_until = ? WHERE id = ?`),
-        updateTier: db.prepare(`UPDATE memories SET tier = ?, last_accessed = ? WHERE id = ?`),
-        getByTier: db.prepare(`SELECT * FROM memories WHERE tier = ? ORDER BY last_accessed DESC`),
-        getByTierAndScope: db.prepare(`SELECT * FROM memories WHERE tier = ? AND (scope = 'global' OR scope = ?) ORDER BY last_accessed DESC`),
-        // Session summaries
-        insertSummary: db.prepare(`INSERT OR REPLACE INTO session_summaries (id, session_id, summary, key_decisions, key_corrections, memories_extracted, project, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`),
-        getSummaryBySession: db.prepare(`SELECT * FROM session_summaries WHERE session_id = ?`),
-        getRecentSummaries: db.prepare(`SELECT * FROM session_summaries WHERE project = ? ORDER BY created_at DESC LIMIT ?`),
-        // Temporal relations
-        expireRelation: db.prepare(`UPDATE memory_relations SET valid_until = ? WHERE id = ?`),
-        getValidRelations: db.prepare(`SELECT * FROM memory_relations WHERE (valid_until IS NULL OR valid_until > ?) ORDER BY created_at DESC`),
-        // Self-evolving loop
-        insertLineage: db.prepare(`INSERT OR IGNORE INTO synthesis_lineage (synthesis_id, source_id, created_at) VALUES (?, ?, ?)`),
-        getLineageSources: db.prepare(`SELECT source_id FROM synthesis_lineage WHERE synthesis_id = ?`),
-        getLineageBySrc: db.prepare(`SELECT DISTINCT synthesis_id FROM synthesis_lineage WHERE source_id = ?`),
-        findGapByPattern: db.prepare(`SELECT * FROM knowledge_gaps WHERE query_pattern = ? AND resolved = 0 LIMIT 1`),
-        insertGap: db.prepare(`INSERT INTO knowledge_gaps (id, query_pattern, hit_count, avg_confidence, avg_results, first_seen, last_seen, resolved) VALUES (?, ?, 1, ?, ?, ?, ?, 0)`),
-        updateGap: db.prepare(`UPDATE knowledge_gaps SET avg_confidence = (avg_confidence * hit_count + ?) / (hit_count + 1), avg_results = (avg_results * hit_count + ?) / (hit_count + 1), hit_count = hit_count + 1, last_seen = ? WHERE id = ?`),
-        getActiveGaps: db.prepare(`SELECT * FROM knowledge_gaps WHERE resolved = 0 ORDER BY hit_count DESC LIMIT ?`),
-        resolveGap: db.prepare(`UPDATE knowledge_gaps SET resolved = 1 WHERE id = ?`),
-        bumpUtility: db.prepare(`UPDATE memories SET utility_score = utility_score + 1 WHERE id = ?`),
-        getMeta: db.prepare(`SELECT value FROM reflection_meta WHERE key = ?`),
-        setMeta: db.prepare(`INSERT OR REPLACE INTO reflection_meta (key, value, updated_at) VALUES (?, ?, ?)`),
-    };
-    // Keep FTS index in sync via triggers.
-    // External-content FTS5 tables require explicit rowid in all operations.
-    // Drop and recreate triggers to pick up the rowid fix for existing DBs.
-    db.exec(`
-    DROP TRIGGER IF EXISTS memories_ai;
-    DROP TRIGGER IF EXISTS memories_ad;
-    DROP TRIGGER IF EXISTS memories_au;
-    DROP TRIGGER IF EXISTS log_ai;
-    DROP TRIGGER IF EXISTS log_ad;
-    DROP TRIGGER IF EXISTS log_au;
-
-    CREATE TRIGGER memories_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, id, content, tags) VALUES (new.rowid, new.id, new.content, new.tags);
-    END;
-    CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, id, content, tags) VALUES ('delete', old.rowid, old.id, old.content, old.tags);
-    END;
-    CREATE TRIGGER memories_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, id, content, tags) VALUES ('delete', old.rowid, old.id, old.content, old.tags);
-      INSERT INTO memories_fts(rowid, id, content, tags) VALUES (new.rowid, new.id, new.content, new.tags);
-    END;
-    CREATE TRIGGER log_ai AFTER INSERT ON conversation_log BEGIN
-      INSERT INTO log_fts(rowid, id, content) VALUES (new.rowid, new.id, new.content);
-    END;
-    CREATE TRIGGER log_ad AFTER DELETE ON conversation_log BEGIN
-      INSERT INTO log_fts(log_fts, rowid, id, content) VALUES ('delete', old.rowid, old.id, old.content);
-    END;
-    CREATE TRIGGER log_au AFTER UPDATE ON conversation_log BEGIN
-      INSERT INTO log_fts(log_fts, rowid, id, content) VALUES ('delete', old.rowid, old.id, old.content);
-      INSERT INTO log_fts(rowid, id, content) VALUES (new.rowid, new.id, new.content);
-    END;
-  `);
-    return {
-        insertMemory(input) {
-            const id = randomUUID();
-            const now = Date.now();
-            const embeddingBuffer = input.embedding
-                ? Buffer.from(input.embedding.buffer, input.embedding.byteOffset, input.embedding.byteLength)
-                : null;
-            const contentHash = createHash("sha256").update(input.content).digest("hex").slice(0, 16);
-            stmts.insert.run(id, input.content, input.type, JSON.stringify(input.tags), input.confidence, now, now, input.source, embeddingBuffer, input.scope, contentHash, input.validFrom ?? now, input.validUntil ?? null, input.tier ?? "archival");
-            return id;
-        },
-        findByContentHash(content) {
-            const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
-            const row = stmts.findByContentHash.get(hash);
-            return row ? rowToMemory(row) : null;
-        },
-        getById(id) {
-            const row = stmts.getById.get(id);
-            return row ? rowToMemory(row) : null;
-        },
-        searchByType(type) {
-            const rows = stmts.searchByType.all(type);
-            return rows.map(rowToMemory);
-        },
-        searchByTag(tag) {
-            const pattern = `%"${tag}"%`;
-            const rows = stmts.searchByTag.all(pattern);
-            return rows.map(rowToMemory);
-        },
-        getAllWithEmbeddings() {
-            const rows = stmts.getAllWithEmbeddings.all();
-            return rows.map(rowToMemory);
-        },
-        getRecentWithEmbeddings(limit) {
-            const rows = stmts.getRecentWithEmbeddings.all(limit);
-            return rows.map(rowToMemory);
-        },
-        getAll() {
-            const rows = stmts.getAll.all();
-            return rows.map(rowToMemory);
-        },
-        updateConfidence(id, confidence) {
-            stmts.updateConfidence.run(confidence, Date.now(), id);
-        },
-        updateEmbedding(id, embedding) {
-            const buffer = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-            stmts.updateEmbedding.run(buffer, id);
-        },
-        touchAccess(id) {
-            stmts.touchAccess.run(Date.now(), id);
-        },
-        deleteMemory(id) {
-            stmts.deleteMemory.run(id);
-        },
-        getStats() {
-            const total = stmts.countAll.get().count;
-            const typeCounts = stmts.countByType.all();
-            const byType = {};
-            for (const row of typeCounts) {
-                byType[row.type] = row.count;
-            }
-            return { total, byType };
-        },
-        getConfidenceStats() {
-            return {
-                high: stmts.countHighConf.get().count,
-                medium: stmts.countMedConf.get().count,
-                low: stmts.countLowConf.get().count,
-            };
-        },
-        getEmbeddingCount() {
-            return stmts.countWithEmbeddings.get().count;
-        },
-        searchByScope(scope) {
-            const rows = stmts.searchByScope.all(scope);
-            return rows.map(rowToMemory);
-        },
-        getAllForProject(project) {
-            const rows = stmts.getAllForProject.all(project);
-            return rows.map(rowToMemory);
-        },
-        listTables() {
-            const rows = stmts.listTables.all();
-            return rows.map((r) => r.name);
-        },
-        close() {
-            db.close();
-        },
-        // ── Raw log ──────────────────────────────────────────────
-        appendLog(entry) {
-            const id = randomUUID();
-            stmts.insertLog.run(id, entry.sessionId, entry.role, entry.content, Date.now(), entry.project, JSON.stringify(entry.metadata ?? {}));
-            return id;
-        },
-        getLogBySession(sessionId) {
-            const rows = stmts.getLogBySession.all(sessionId);
-            return rows.map(r => ({
-                id: r.id,
-                sessionId: r.session_id,
-                role: r.role,
-                content: r.content,
-                timestamp: r.timestamp,
-                project: r.project,
-                metadata: JSON.parse(r.metadata),
-            }));
-        },
-        searchLog(query, limit = 20) {
-            const mapRow = (r) => ({
-                id: r.id,
-                sessionId: r.session_id,
-                role: r.role,
-                content: r.content,
-                timestamp: r.timestamp,
-                project: r.project,
-                metadata: JSON.parse(r.metadata),
-            });
-            try {
-                const stmt = db.prepare(`
-          SELECT conversation_log.* FROM log_fts
-          JOIN conversation_log ON conversation_log.id = log_fts.id
-          WHERE log_fts.content MATCH ?
-          ORDER BY rank
-          LIMIT ?
-        `);
-                const rows = stmt.all(query, limit);
-                return rows.map(mapRow);
-            }
-            catch (error) {
-                // FTS5 may fail on special characters — fall back to LIKE
-                console.error("[amem] FTS5 log search failed, falling back to LIKE:", error instanceof Error ? error.message : String(error));
-                const escaped = query.replace(/[%_]/g, ch => "\\" + ch);
-                const pattern = `%${escaped}%`;
-                const stmt = db.prepare(`
-          SELECT * FROM conversation_log WHERE content LIKE ? ESCAPE '\\' ORDER BY timestamp DESC LIMIT ?
-        `);
-                const rows = stmt.all(pattern, limit);
-                return rows.map(mapRow);
-            }
-        },
-        getRecentLog(limit, project) {
-            const rows = (project
-                ? stmts.getRecentLogByProject.all(project, limit)
-                : stmts.getRecentLog.all(limit));
-            return rows.map(r => ({
-                id: r.id,
-                sessionId: r.session_id,
-                role: r.role,
-                content: r.content,
-                timestamp: r.timestamp,
-                project: r.project,
-                metadata: JSON.parse(r.metadata),
-            }));
-        },
-        deleteLogBefore(timestamp) {
-            const result = stmts.deleteLogBefore.run(timestamp);
-            return result.changes;
-        },
-        getLogCount() {
-            return stmts.countLog.get().count;
-        },
-        // ── Versioning ──────────────────────────────────────────
-        snapshotVersion(memoryId, reason) {
-            const mem = this.getById(memoryId);
-            if (!mem)
-                return;
-            stmts.insertVersion.run(randomUUID(), mem.id, mem.content, mem.confidence, Date.now(), reason);
-        },
-        getVersionHistory(memoryId) {
-            const rows = stmts.getVersions.all(memoryId);
-            return rows.map(r => ({
-                versionId: r.version_id,
-                memoryId: r.memory_id,
-                content: r.content,
-                confidence: r.confidence,
-                editedAt: r.edited_at,
-                reason: r.reason,
-            }));
-        },
-        patchMemory(id, patch) {
-            const mem = this.getById(id);
-            if (!mem)
-                return false;
-            // Snapshot before patching (can be skipped for batch operations like restore)
-            if (!patch.skipSnapshot) {
-                this.snapshotVersion(id, `before patch: ${patch.reason}`);
-            }
-            const now = Date.now();
-            switch (patch.field) {
-                case "content":
-                    stmts.updateContent.run(patch.value, now, id);
-                    break;
-                case "confidence":
-                    stmts.updateConfidence.run(patch.value, now, id);
-                    break;
-                case "tags":
-                    stmts.updateTags.run(JSON.stringify(patch.value), now, id);
-                    break;
-                case "type":
-                    stmts.updateType.run(patch.value, now, id);
-                    break;
-                default:
-                    return false;
-            }
-            return true;
-        },
-        // ── Relations ────────────────────────────────────────────
-        addRelation(fromId, toId, type, strength = 0.8) {
-            const id = randomUUID();
-            const now = Date.now();
-            stmts.insertRelation.run(id, fromId, toId, type, strength, now, now);
-            return id;
-        },
-        getRelations(memoryId) {
-            const from = stmts.getRelationsFrom.all(memoryId);
-            const to = stmts.getRelationsTo.all(memoryId);
-            return [...from, ...to].map(rowToRelation);
-        },
-        removeRelation(relationId) {
-            stmts.deleteRelation.run(relationId);
-        },
-        getRelatedMemories(memoryId) {
-            const relations = this.getRelations(memoryId);
-            const ids = relations.map(r => r.fromId === memoryId ? r.toId : r.fromId);
-            return ids
-                .map(id => this.getById(id))
-                .filter((m) => m !== null);
-        },
-        // ── Temporal queries ─────────────────────────────────────
-        getMemoriesByDateRange(from, to) {
-            const rows = stmts.getByDateRange.all(from, to);
-            return rows.map(rowToMemory);
-        },
-        getMemoriesSince(timestamp) {
-            const rows = stmts.getSince.all(timestamp);
-            return rows.map(rowToMemory);
-        },
-        // ── Reminders ────────────────────────────────────────────
-        insertReminder(content, dueAt, scope) {
-            const id = randomUUID();
-            stmts.insertReminder.run(id, content, dueAt, Date.now(), scope);
-            return id;
-        },
-        listReminders(includeCompleted = false, scope) {
-            const rows = (scope
-                ? (includeCompleted ? stmts.listAllRemindersByScope.all(scope) : stmts.listRemindersByScope.all(scope))
-                : (includeCompleted ? stmts.listAllReminders.all() : stmts.listReminders.all()));
-            return rows.map(r => ({
-                id: r.id, content: r.content, dueAt: r.due_at,
-                completed: r.completed === 1, createdAt: r.created_at, scope: r.scope,
-            }));
-        },
-        checkReminders() {
-            const reminders = this.listReminders();
-            const todayStart = new Date();
-            todayStart.setHours(0, 0, 0, 0);
-            const todayEnd = new Date();
-            todayEnd.setHours(23, 59, 59, 999);
-            const weekFromNow = Date.now() + 7 * 24 * 60 * 60 * 1000;
-            return reminders
-                .filter(r => r.dueAt !== null)
-                .map(r => {
-                let status;
-                if (r.dueAt < todayStart.getTime())
-                    status = "overdue";
-                else if (r.dueAt <= todayEnd.getTime())
-                    status = "today";
-                else
-                    status = "upcoming";
-                return { id: r.id, content: r.content, dueAt: r.dueAt, status, scope: r.scope };
-            })
-                .filter(r => r.status === "overdue" || r.status === "today" || r.dueAt <= weekFromNow);
-        },
-        completeReminder(id) {
-            const result = stmts.completeReminder.run(id);
-            return result.changes > 0;
-        },
-        // ── Full-text search ─────────────────────────────────────
-        fullTextSearch(query, limit = 20, scopeProject) {
-            try {
-                // Sanitize query for FTS5: quote each token to prevent column prefix
-                // interpretation (e.g. "partner:" being parsed as column "partner")
-                const sanitized = query
-                    .replace(/["\u201C\u201D]/g, "") // strip existing quotes
-                    .split(/\s+/)
-                    .filter(Boolean)
-                    .map(token => `"${token.replace(/:/g, "")}"`) // quote tokens, strip colons
-                    .join(" ");
-                if (!sanitized)
-                    throw new Error("empty query after sanitization");
-                if (scopeProject) {
-                    const stmt = db.prepare(`
-            SELECT memories.* FROM memories_fts
-            JOIN memories ON memories.id = memories_fts.id
-            WHERE memories_fts MATCH ? AND (memories.scope = 'global' OR memories.scope = ?)
-            ORDER BY rank
-            LIMIT ?
-          `);
-                    const rows = stmt.all(sanitized, scopeProject, limit);
-                    return rows.map(rowToMemory);
-                }
-                const stmt = db.prepare(`
-          SELECT memories.* FROM memories_fts
-          JOIN memories ON memories.id = memories_fts.id
-          WHERE memories_fts MATCH ?
-          ORDER BY rank
-          LIMIT ?
-        `);
-                const rows = stmt.all(sanitized, limit);
-                return rows.map(rowToMemory);
-            }
-            catch (error) {
-                // FTS may fail on complex queries — fall back to LIKE
-                console.error("[amem] FTS5 memory search failed, falling back to LIKE:", error instanceof Error ? error.message : String(error));
-                const escaped = query.replace(/[%_]/g, ch => "\\" + ch);
-                const pattern = `%${escaped}%`;
-                if (scopeProject) {
-                    const stmt = db.prepare(`
-            SELECT * FROM memories WHERE (content LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\')
-            AND (scope = 'global' OR scope = ?) ORDER BY last_accessed DESC LIMIT ?
-          `);
-                    const rows = stmt.all(pattern, pattern, scopeProject, limit);
-                    return rows.map(rowToMemory);
-                }
-                const stmt = db.prepare(`
-          SELECT * FROM memories WHERE content LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\' ORDER BY last_accessed DESC LIMIT ?
-        `);
-                const rows = stmt.all(pattern, pattern, limit);
-                return rows.map(rowToMemory);
-            }
-        },
-        // ── Utilities ────────────────────────────────────────────
-        transaction(fn) {
-            runTransaction(fn);
-        },
-        resolveId(partialId) {
-            if (partialId.length >= 36) {
-                const mem = this.getById(partialId);
-                return mem ? partialId : null;
-            }
-            const rows = stmts.resolveIdPrefix.all(`${partialId}%`);
-            if (rows.length === 1)
-                return rows[0].id;
-            return null;
-        },
-        resolveReminderId(partialId) {
-            if (partialId.length >= 36)
-                return partialId;
-            const rows = stmts.resolveReminderIdPrefix.all(`${partialId}%`);
-            if (rows.length === 1)
-                return rows[0].id;
-            return null;
-        },
-        getAllRelations() {
-            const rows = stmts.getAllRelations.all();
-            return rows.map(rowToRelation);
-        },
-        // ── Temporal validity ───────────────────────────────────
-        expireMemory(id, timestamp) {
-            stmts.expireMemory.run(timestamp ?? Date.now(), id);
-        },
-        getValidMemories(asOf) {
-            const rows = stmts.getValidMemories.all(asOf ?? Date.now());
-            return rows.map(rowToMemory);
-        },
-        updateTier(id, tier) {
-            stmts.updateTier.run(tier, Date.now(), id);
-        },
-        getByTier(tier, scope) {
-            const rows = scope
-                ? stmts.getByTierAndScope.all(tier, scope)
-                : stmts.getByTier.all(tier);
-            return rows.map(rowToMemory);
-        },
-        // ── Session summaries ───────────────────────────────────
-        insertSummary(input) {
-            const id = randomUUID();
-            stmts.insertSummary.run(id, input.sessionId, input.summary, JSON.stringify(input.keyDecisions), JSON.stringify(input.keyCorrections), input.memoriesExtracted, input.project, Date.now());
-            return id;
-        },
-        getSummaryBySession(sessionId) {
-            const row = stmts.getSummaryBySession.get(sessionId);
-            return row ? rowToSummary(row) : null;
-        },
-        getRecentSummaries(project, limit = 10) {
-            const rows = stmts.getRecentSummaries.all(project, limit);
-            return rows.map(rowToSummary);
-        },
-        // ── Temporal relations ──────────────────────────────────
-        expireRelation(relationId, timestamp) {
-            stmts.expireRelation.run(timestamp ?? Date.now(), relationId);
-        },
-        getValidRelations(asOf) {
-            const rows = stmts.getValidRelations.all(asOf ?? Date.now());
-            return rows.map(rowToRelation);
-        },
-        // ── Self-evolving loop ─────────────────────────────────
-        insertSynthesisLineage(synthesisId, sourceIds) {
-            const now = Date.now();
-            for (const sourceId of sourceIds) {
-                stmts.insertLineage.run(synthesisId, sourceId, now);
-            }
-        },
-        getSynthesisSources(synthesisId) {
-            const rows = stmts.getLineageSources.all(synthesisId);
-            return rows.map(r => r.source_id);
-        },
-        hasAnySynthesis(sourceIds) {
-            for (const id of sourceIds) {
-                const row = stmts.getLineageBySrc.get(id);
-                if (row)
-                    return true;
-            }
-            return false;
-        },
-        upsertKnowledgeGap(queryPattern, avgConfidence, resultCount) {
-            const now = Date.now();
-            const existing = stmts.findGapByPattern.get(queryPattern);
-            if (existing) {
-                stmts.updateGap.run(avgConfidence, resultCount, now, existing.id);
-                return existing.id;
-            }
-            const id = randomUUID();
-            stmts.insertGap.run(id, queryPattern, avgConfidence, resultCount, now, now);
-            return id;
-        },
-        getActiveKnowledgeGaps(limit = 10) {
-            const rows = stmts.getActiveGaps.all(limit);
-            return rows.map(r => ({
-                id: r.id,
-                queryPattern: r.query_pattern,
-                hitCount: r.hit_count,
-                avgConfidence: r.avg_confidence,
-                avgResults: r.avg_results,
-                firstSeen: r.first_seen,
-                lastSeen: r.last_seen,
-                resolved: r.resolved === 1,
-            }));
-        },
-        resolveKnowledgeGap(id) {
-            stmts.resolveGap.run(id);
-        },
-        bumpUtilityScore(id) {
-            stmts.bumpUtility.run(id);
-        },
-        getReflectionMeta(key) {
-            const row = stmts.getMeta.get(key);
-            return row?.value ?? null;
-        },
-        setReflectionMeta(key, value) {
-            stmts.setMeta.run(key, value, Date.now());
-        },
-    };
-}
-//# sourceMappingURL=database.js.map