@devflow-tools/memory-engine 0.13.3 → 0.14.1

package/dist/memory-store.js

@@ -3,21 +3,43 @@ import * as sqliteVec from 'sqlite-vec';
 import { join } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
-const SCHEMA = `
+// ── Schema ─────────────────────────────────────────────
+const SCHEMA_V2 = `
+-- ============================================================
+-- Core: memories (expanded from v1)
+-- ============================================================
 CREATE TABLE IF NOT EXISTS memories (
-  id TEXT PRIMARY KEY,
-  category TEXT NOT NULL CHECK(category IN ('procedural','semantic','episodic','failure_lesson','mcp_correction','project_knowledge')),
-  content TEXT NOT NULL,
-  original_text TEXT,
-  source TEXT NOT NULL DEFAULT 'auto',
-  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','approved','rejected','expired')),
-  confidence REAL NOT NULL DEFAULT 0.5,
-  scope TEXT NOT NULL DEFAULT '',
-  session_id TEXT,
-  created_at INTEGER NOT NULL,
-  approved_at INTEGER
+  id                TEXT PRIMARY KEY,
+  type              TEXT NOT NULL DEFAULT 'fact'
+                    CHECK(type IN ('constraint','pattern','preference','lesson','fact',
+                                   'semantic','episodic','procedural','failure_lesson',
+                                   'mcp_correction','project_knowledge')),
+  title             TEXT NOT NULL DEFAULT '',
+  content           TEXT NOT NULL,
+  context           TEXT NOT NULL DEFAULT '',
+  original_text     TEXT,
+  source            TEXT NOT NULL DEFAULT 'auto',
+  status            TEXT NOT NULL DEFAULT 'active'
+                    CHECK(status IN ('active','superseded','expired','pending','approved','rejected')),
+  version           INTEGER NOT NULL DEFAULT 1,
+  supersedes        TEXT,
+  superseded_by     TEXT,
+  strength          REAL NOT NULL DEFAULT 0.5,
+  confidence        REAL NOT NULL DEFAULT 0.5,
+  tags              TEXT NOT NULL DEFAULT '[]',
+  scope             TEXT NOT NULL DEFAULT '',
+  session_id        TEXT,
+  created_at        INTEGER NOT NULL,
+  updated_at        INTEGER NOT NULL,
+  last_reinforced_at INTEGER,
+  expires_at        INTEGER,
+  access_count      INTEGER NOT NULL DEFAULT 0,
+  reinforce_count   INTEGER NOT NULL DEFAULT 0
 );
 
+-- ============================================================
+-- FTS5 keyword index
+-- ============================================================
 CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
   id UNINDEXED,
   content,
@@ -26,110 +48,358 @@ CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
   tokenize='porter unicode61'
 );
 
+-- ============================================================
+-- Vector search (sqlite-vec)
+-- ============================================================
 CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec USING vec0(
   id TEXT PRIMARY KEY,
   embedding FLOAT[384]
 );
 
+-- ============================================================
+-- Memory relationship edges
+-- ============================================================
 CREATE TABLE IF NOT EXISTS memory_edges (
   source_id TEXT NOT NULL,
   target_id TEXT NOT NULL,
-  relation TEXT NOT NULL,
-  weight REAL DEFAULT 1.0,
-  PRIMARY KEY (source_id, target_id, relation),
+  type      TEXT NOT NULL CHECK(type IN ('contradicts','related_to','supersedes','references')),
+  weight    REAL NOT NULL DEFAULT 0.5,
+  PRIMARY KEY (source_id, target_id, type),
   FOREIGN KEY (source_id) REFERENCES memories(id) ON DELETE CASCADE,
   FOREIGN KEY (target_id) REFERENCES memories(id) ON DELETE CASCADE
 );
 
-CREATE TABLE IF NOT EXISTS events (
-  id TEXT PRIMARY KEY,
-  session_id TEXT NOT NULL,
-  tool TEXT NOT NULL,
-  command TEXT,
-  exit_code INTEGER,
-  stderr TEXT,
-  duration_ms INTEGER,
-  created_at INTEGER NOT NULL,
-  processed INTEGER NOT NULL DEFAULT 0
+-- ============================================================
+-- Evidence chain (one memory → many evidence records)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS evidence (
+  id                     TEXT PRIMARY KEY,
+  memory_id              TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  type                   TEXT NOT NULL CHECK(type IN ('error_pattern','user_correction','explicit_save','recurrence','consolidation')),
+  weight                 REAL NOT NULL DEFAULT 0.5,
+  source_observation_ids TEXT NOT NULL DEFAULT '[]',
+  summary                TEXT NOT NULL DEFAULT '',
+  timestamp              INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_evidence_memory ON evidence(memory_id);
+
+-- ============================================================
+-- Memory change audit log
+-- ============================================================
+CREATE TABLE IF NOT EXISTS memory_history (
+  id           TEXT PRIMARY KEY,
+  memory_id    TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  event        TEXT NOT NULL CHECK(event IN ('ADD','UPDATE','DELETE','REINFORCE','SUPERSEDE','EXPIRE','EVICT')),
+  old_content  TEXT,
+  new_content  TEXT,
+  old_strength REAL,
+  new_strength REAL,
+  reason       TEXT NOT NULL DEFAULT '',
+  created_at   INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_memory_history_memory ON memory_history(memory_id);
+
+-- ============================================================
+-- Sessions
+-- ============================================================
+CREATE TABLE IF NOT EXISTS sessions (
+  id             TEXT PRIMARY KEY,
+  project_root   TEXT NOT NULL,
+  task           TEXT NOT NULL DEFAULT '',
+  status         TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','closed')),
+  phase_summary  TEXT NOT NULL DEFAULT '[]',
+  signal_summary TEXT NOT NULL DEFAULT '[]',
+  tool_count     INTEGER NOT NULL DEFAULT 0,
+  error_count    INTEGER NOT NULL DEFAULT 0,
+  created_at     INTEGER NOT NULL,
+  closed_at      INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_root);
+
+-- ============================================================
+-- Session events (raw tool calls)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS session_events (
+  id           TEXT PRIMARY KEY,
+  session_id   TEXT NOT NULL,
+  project      TEXT NOT NULL DEFAULT '',
+  tool         TEXT NOT NULL,
+  command      TEXT,
+  exit_code    INTEGER,
+  stderr       TEXT,
+  duration_ms  INTEGER,
+  created_at   INTEGER NOT NULL,
+  processed    INTEGER NOT NULL DEFAULT 0,
+  l1_score     REAL NOT NULL DEFAULT 0,
+  dialog_score REAL NOT NULL DEFAULT 0,
+  user_message TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id);
+CREATE INDEX IF NOT EXISTS idx_session_events_project ON session_events(project);
+CREATE INDEX IF NOT EXISTS idx_session_events_processed ON session_events(processed);
+
+-- ============================================================
+-- Observations (Summarizer output — intermediate layer)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS observations (
+  id               TEXT PRIMARY KEY,
+  session_id       TEXT NOT NULL,
+  project          TEXT NOT NULL DEFAULT '',
+  type             TEXT NOT NULL CHECK(type IN (
+    'error_resolution','error_unresolved','config_discovery',
+    'tool_first_use','decision_made','user_insight',
+    'file_operation','session_summary'
+  )),
+  title            TEXT NOT NULL,
+  narrative        TEXT NOT NULL DEFAULT '',
+  facts            TEXT NOT NULL DEFAULT '[]',
+  files            TEXT NOT NULL DEFAULT '[]',
+  tools            TEXT NOT NULL DEFAULT '[]',
+  concepts         TEXT NOT NULL DEFAULT '[]',
+  importance       INTEGER NOT NULL DEFAULT 5,
+  confidence       REAL NOT NULL DEFAULT 0.5,
+  source_event_ids TEXT NOT NULL DEFAULT '[]',
+  memory_id        TEXT,
+  embedding        BLOB,
+  timestamp        INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project);
+CREATE INDEX IF NOT EXISTS idx_observations_memory ON observations(memory_id);
+CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
+
+-- ============================================================
+-- Observation → Concept junction (inverted index for clustering)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS observation_concepts (
+  observation_id TEXT NOT NULL REFERENCES observations(id) ON DELETE CASCADE,
+  concept        TEXT NOT NULL COLLATE NOCASE,
+  PRIMARY KEY (observation_id, concept)
+);
+CREATE INDEX IF NOT EXISTS idx_obs_concepts_concept ON observation_concepts(concept);
+
+-- ============================================================
+-- Unified raw embedding storage (memory + observation)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS embeddings (
+  source_type TEXT NOT NULL CHECK(source_type IN ('memory','observation')),
+  source_id   TEXT NOT NULL,
+  vector      BLOB NOT NULL,
+  PRIMARY KEY (source_type, source_id)
+);
+CREATE INDEX IF NOT EXISTS idx_embeddings_source ON embeddings(source_type, source_id);
+
+-- ============================================================
+-- Access log (drives reinforcement boost)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS access_log (
+  id          TEXT PRIMARY KEY,
+  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  access_type TEXT NOT NULL CHECK(access_type IN ('search_hit','user_view','agent_use','manual_ref')),
+  session_id  TEXT,
+  timestamp   INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_access_log_memory ON access_log(memory_id);
+CREATE INDEX IF NOT EXISTS idx_access_log_timestamp ON access_log(timestamp);
+
+-- ============================================================
+-- Retention score cache
+-- ============================================================
+CREATE TABLE IF NOT EXISTS retention_scores (
+  memory_id            TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+  score                REAL NOT NULL,
+  salience             REAL NOT NULL,
+  temporal_decay       REAL NOT NULL,
+  reinforcement_boost  REAL NOT NULL,
+  last_accessed        INTEGER,
+  access_count         INTEGER NOT NULL DEFAULT 0,
+  computed_at          INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_retention_score ON retention_scores(score);
+
+-- ============================================================
+-- Signals (Signal Detector output)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS signals (
+  id               TEXT PRIMARY KEY,
+  session_id       TEXT NOT NULL,
+  type             TEXT NOT NULL,
+  strength         REAL NOT NULL DEFAULT 0.5,
+  source_event_ids TEXT NOT NULL DEFAULT '[]',
+  payload          TEXT NOT NULL DEFAULT '{}',
+  timestamp        INTEGER NOT NULL
 );
-CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
-CREATE INDEX IF NOT EXISTS idx_events_processed ON events(processed);
+CREATE INDEX IF NOT EXISTS idx_signals_session ON signals(session_id);
+CREATE INDEX IF NOT EXISTS idx_signals_type ON signals(type);
 `;
 const FTS_TRIGGERS = `
 CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-  INSERT INTO memories_fts(rowid, id, content, scope) VALUES (new.rowid, new.id, new.content, new.scope);
+  INSERT INTO memories_fts(rowid, id, content, scope)
+  VALUES (new.rowid, new.id, new.content, new.scope);
 END;
 CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-  INSERT INTO memories_fts(memories_fts, id, content, scope) VALUES('delete', old.id, old.content, old.scope);
+  INSERT INTO memories_fts(memories_fts, id, content, scope)
+  VALUES ('delete', old.id, old.content, old.scope);
 END;
 CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-  INSERT INTO memories_fts(memories_fts, id, content, scope) VALUES('delete', old.id, old.content, old.scope);
-  INSERT INTO memories_fts(rowid, id, content, scope) VALUES (new.rowid, new.id, new.content, new.scope);
+  INSERT INTO memories_fts(memories_fts, id, content, scope)
+  VALUES ('delete', old.id, old.content, old.scope);
+  INSERT INTO memories_fts(rowid, id, content, scope)
+  VALUES (new.rowid, new.id, new.content, new.scope);
 END;
 `;
+// ── MemoryStore ─────────────────────────────────────────
 export class MemoryStore {
     db;
+    dbPath;
     constructor(rootPath) {
         const memDir = join(rootPath, '.devflow', 'memory');
         if (!existsSync(memDir))
             mkdirSync(memDir, { recursive: true });
-        const dbPath = join(memDir, 'memories.db');
-        this.db = new Database(dbPath);
+        this.dbPath = join(memDir, 'memories.db');
+        this.db = new Database(this.dbPath);
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('busy_timeout = 5000');
         this.db.pragma('foreign_keys = ON');
         sqliteVec.load(this.db);
-        this.db.exec(SCHEMA);
+        this.db.exec(SCHEMA_V2);
         this.db.exec(FTS_TRIGGERS);
-        this.migrateSchema();
+        this.migrateV1ToV2();
+        console.log('[MemoryStore] Schema initialized', {
+            dbPath: this.dbPath,
+            tableCount: this.countTables(),
+        });
     }
+    countTables() {
+        const row = this.db.prepare("SELECT COUNT(*) as c FROM sqlite_master WHERE type='table'").get();
+        return row.c;
+    }
+    // ── V1 → V2 Migration ────────────────────────────
+    migrateV1ToV2() {
+        const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(r => r.name);
+        // If old 'events' table exists, migrate data to session_events
+        if (tables.includes('events') && tables.includes('session_events')) {
+            const count = this.db.prepare('SELECT COUNT(*) as c FROM events').get();
+            if (count.c > 0) {
+                try {
+                    this.db.exec(`
+            INSERT OR IGNORE INTO session_events
+              (id, session_id, project, tool, command, exit_code, stderr,
+               duration_ms, created_at, processed, l1_score, dialog_score, user_message)
+            SELECT id, session_id, '', tool, command, exit_code, stderr,
+                   duration_ms, created_at, processed,
+                   COALESCE(l1_score, 0), COALESCE(dialog_score, 0), user_message
+            FROM events
+          `);
+                    console.log('[MemoryStore] Migrated', count.c, 'events to session_events');
+                }
+                catch (err) {
+                    console.warn('[MemoryStore] Event migration skipped:', err.message);
+                }
+            }
+        }
+        // Add new columns to memories table if missing
+        const memCols = this.getTableColumns('memories');
+        const newCols = [
+            { name: 'title', sql: "ALTER TABLE memories ADD COLUMN title TEXT NOT NULL DEFAULT ''" },
+            { name: 'type', sql: "ALTER TABLE memories ADD COLUMN type TEXT" },
+            { name: 'version', sql: 'ALTER TABLE memories ADD COLUMN version INTEGER NOT NULL DEFAULT 1' },
+            { name: 'supersedes', sql: 'ALTER TABLE memories ADD COLUMN supersedes TEXT' },
+            { name: 'superseded_by', sql: 'ALTER TABLE memories ADD COLUMN superseded_by TEXT' },
+            { name: 'tags', sql: "ALTER TABLE memories ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'" },
+            { name: 'context', sql: "ALTER TABLE memories ADD COLUMN context TEXT NOT NULL DEFAULT ''" },
+            { name: 'strength', sql: 'ALTER TABLE memories ADD COLUMN strength REAL NOT NULL DEFAULT 0.5' },
+            { name: 'last_reinforced_at', sql: 'ALTER TABLE memories ADD COLUMN last_reinforced_at INTEGER' },
+            { name: 'reinforce_count', sql: 'ALTER TABLE memories ADD COLUMN reinforce_count INTEGER NOT NULL DEFAULT 0' },
+            { name: 'updated_at', sql: 'ALTER TABLE memories ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0' },
+        ];
+        for (const col of newCols) {
+            if (!memCols.includes(col.name)) {
+                try {
+                    this.db.exec(col.sql);
+                }
+                catch { /* column may already exist */ }
+            }
+        }
+        // Backfill: copy category→type, set title from first sentence of content
+        if (!memCols.includes('type') && memCols.includes('category')) {
+            try {
+                this.db.exec("UPDATE memories SET type = category WHERE type IS NULL");
+            }
+            catch { /* ignore */ }
+        }
+        if (!memCols.includes('title')) {
+            try {
+                this.db.exec("UPDATE memories SET title = COALESCE(title, '') WHERE title IS NULL OR title = ''");
+            }
+            catch { /* ignore */ }
+        }
+        if (!memCols.includes('updated_at')) {
+            try {
+                this.db.exec('UPDATE memories SET updated_at = created_at WHERE updated_at = 0');
+            }
+            catch { /* ignore */ }
+        }
+        // Wire up old 'events' view for backward compat
+        if (tables.includes('events') && !tables.includes('events')) {
+            // already handled — old callers use session_events directly
+        }
+    }
+    getTableColumns(table) {
+        try {
+            const rows = this.db.pragma(`table_info(${table})`);
+            return rows.map(r => r.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    // ── Memory CRUD ──────────────────────────────────
     add(entry) {
         const id = entry.id ?? `mem:${Date.now()}:${randomUUID().slice(0, 8)}`;
         const now = Date.now();
-        const approvedAt = entry.status === 'approved' ? now : null;
+        const memType = entry.type ?? entry.category ?? 'fact';
+        const title = entry.title ?? entry.content.slice(0, 80);
         this.db.prepare(`
-      INSERT INTO memories (id, category, content, original_text, source, status, confidence, scope, session_id, created_at, approved_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, entry.category, entry.content, entry.originalText ?? null, entry.source ?? 'auto', entry.status ?? 'pending', entry.confidence ?? 0.5, entry.scope ?? '', entry.sessionId ?? null, now, approvedAt);
+      INSERT INTO memories (id, type, title, content, original_text, source, status,
+        confidence, strength, scope, session_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, memType, title, entry.content, entry.originalText ?? null, entry.source ?? 'auto', entry.status ?? 'active', entry.confidence ?? 0.5, entry.strength ?? 0.5, entry.scope ?? '', entry.sessionId ?? null, now, now);
+        console.log('[MemoryStore] Memory added', { id, type: memType, status: entry.status ?? 'active' });
         return this.get(id);
     }
     get(id) {
-        const row = this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id);
-        return row ?? null;
+        return this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id) ?? null;
     }
     update(id, updates) {
         const sets = [];
         const vals = [];
-        if (updates.content !== undefined) {
-            sets.push('content = ?');
-            vals.push(updates.content);
-        }
-        if (updates.status !== undefined) {
-            sets.push('status = ?');
-            vals.push(updates.status);
-        }
-        if (updates.scope !== undefined) {
-            sets.push('scope = ?');
-            vals.push(updates.scope);
-        }
-        if (updates.status === 'approved') {
-            sets.push('approved_at = ?');
-            vals.push(Date.now());
+        for (const [key, value] of Object.entries(updates)) {
+            if (value !== undefined) {
+                const col = camelToSnake(key);
+                sets.push(`${col} = ?`);
+                vals.push(value);
+            }
         }
+        sets.push('updated_at = ?');
+        vals.push(Date.now());
         if (sets.length === 0)
             return;
         vals.push(id);
         this.db.prepare(`UPDATE memories SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+        console.log('[MemoryStore] Memory updated', { id, keys: Object.keys(updates) });
     }
     delete(id) {
         this.db.prepare('DELETE FROM memories WHERE id = ?').run(id);
     }
     list(filter) {
-        let sql = 'SELECT * FROM memories WHERE 1=1';
+        let sql = 'SELECT * FROM memories WHERE superseded_by IS NULL';
         const vals = [];
-        if (filter?.category) {
-            sql += ' AND category = ?';
-            vals.push(filter.category);
+        const typeFilter = filter?.type ?? filter?.category;
+        if (typeFilter) {
+            sql += ' AND type = ?';
+            vals.push(typeFilter);
         }
         if (filter?.status) {
             sql += ' AND status = ?';
@@ -139,145 +409,462 @@ export class MemoryStore {
             sql += ' AND scope = ?';
             vals.push(filter.scope);
         }
-        sql += ' ORDER BY created_at DESC';
+        sql += ' ORDER BY updated_at DESC';
         return this.db.prepare(sql).all(...vals);
     }
     getPending() {
         return this.list({ status: 'pending' });
     }
+    listByType(type, limit = 100) {
+        return this.db.prepare("SELECT * FROM memories WHERE type = ? AND superseded_by IS NULL AND status IN ('active','approved') ORDER BY updated_at DESC LIMIT ?").all(type, limit);
+    }
+    listByTypes(types, limit = 100) {
+        if (types.length === 0)
+            return [];
+        const placeholders = types.map(() => '?').join(',');
+        return this.db.prepare(`SELECT * FROM memories WHERE type IN (${placeholders}) AND superseded_by IS NULL AND status IN ('active','approved') ORDER BY updated_at DESC LIMIT ?`).all(...types, limit);
+    }
     listByCategory(category, limit = 100) {
-        return this.db.prepare('SELECT * FROM memories WHERE category = ? AND status = ? ORDER BY created_at DESC LIMIT ?').all(category, 'approved', limit);
+        return this.listByType(category, limit);
+    }
+    countByStatus(status) {
+        const row = this.db.prepare('SELECT COUNT(*) as c FROM memories WHERE status = ?').get(status);
+        return row?.c ?? 0;
     }
+    // ── Embedding ────────────────────────────────────
     insertEmbedding(id, embedding) {
         const buffer = Buffer.from(embedding.buffer);
         this.db.prepare('INSERT OR REPLACE INTO memories_vec(id, embedding) VALUES (?, ?)').run(id, buffer);
+        this.db.prepare('INSERT OR REPLACE INTO embeddings(source_type, source_id, vector) VALUES (?, ?, ?)').run('memory', id, buffer);
+    }
+    insertObservationEmbedding(obsId, embedding) {
+        const buffer = Buffer.from(embedding.buffer);
+        this.db.prepare('INSERT OR REPLACE INTO embeddings(source_type, source_id, vector) VALUES (?, ?, ?)').run('observation', obsId, buffer);
+        this.db.prepare('UPDATE observations SET embedding = ? WHERE id = ?').run(buffer, obsId);
+    }
+    getEmbedding(id) {
+        const row = this.db.prepare('SELECT embedding FROM memories_vec WHERE id = ?').get(id);
+        return row?.embedding ?? null;
     }
+    getEmbeddingBySource(sourceType, sourceId) {
+        const row = this.db.prepare('SELECT vector FROM embeddings WHERE source_type = ? AND source_id = ?').get(sourceType, sourceId);
+        return row?.vector ?? null;
+    }
+    // ── Search ───────────────────────────────────────
     searchBM25(query, limit = 20) {
-        const rows = this.db.prepare(`
+        return this.db.prepare(`
       SELECT m.id, rank
       FROM memories_fts f
       JOIN memories m ON m.rowid = f.rowid
-      WHERE memories_fts MATCH ? AND m.status = 'approved'
+      WHERE memories_fts MATCH ? AND m.status IN ('active','approved') AND m.superseded_by IS NULL
       ORDER BY rank LIMIT ?
     `).all(query, limit);
-        return rows;
     }
     searchVector(embedding, limit = 20) {
         const buffer = Buffer.from(embedding.buffer);
-        const rows = this.db.prepare(`
+        return this.db.prepare(`
       SELECT v.id, vec_distance_cosine(v.embedding, ?) as distance
       FROM memories_vec v
       JOIN memories m ON m.id = v.id
-      WHERE m.status = 'approved'
+      WHERE m.status IN ('active','approved') AND m.superseded_by IS NULL
       ORDER BY distance LIMIT ?
     `).all(buffer, limit);
-        return rows;
     }
-    addEdge(sourceId, targetId, relation, weight = 1.0) {
+    // ── Edges ────────────────────────────────────────
+    addEdge(sourceId, targetId, type, weight = 0.5) {
         this.db.prepare(`
-      INSERT OR REPLACE INTO memory_edges (source_id, target_id, relation, weight) VALUES (?, ?, ?, ?)
-    `).run(sourceId, targetId, relation, weight);
+      INSERT OR REPLACE INTO memory_edges (source_id, target_id, type, weight)
+      VALUES (?, ?, ?, ?)
+    `).run(sourceId, targetId, type, weight);
     }
     getNeighbors(id) {
-        return this.db.prepare('SELECT target_id, relation, weight FROM memory_edges WHERE source_id = ?').all(id)
-            .map(r => ({ targetId: r.target_id, relation: r.relation, weight: r.weight }));
-    }
-    getEmbedding(id) {
-        const row = this.db.prepare('SELECT embedding FROM memories_vec WHERE id = ?').get(id);
-        return row?.embedding ?? null;
+        return this.db.prepare('SELECT target_id, type, weight FROM memory_edges WHERE source_id = ?').all(id).map(r => ({ targetId: r.target_id, type: r.type, weight: r.weight }));
     }
-    close() {
-        this.db.close();
-    }
-    // --- Events CRUD ---
+    // ── Events CRUD ──────────────────────────────────
     recordEvent(event) {
         this.db.prepare(`
-      INSERT OR IGNORE INTO events (id, session_id, tool, command, exit_code, stderr, duration_ms, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(event.id, event.sessionId, event.tool, event.command ?? null, event.exitCode ?? null, event.stderr ?? null, event.durationMs ?? null, event.createdAt);
+      INSERT OR IGNORE INTO session_events
+        (id, session_id, project, tool, command, exit_code, stderr,
+         duration_ms, created_at, l1_score, dialog_score, user_message)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(event.id, event.sessionId, event.project ?? '', event.tool, event.command ?? null, event.exitCode ?? null, event.stderr ?? null, event.durationMs ?? null, event.createdAt, event.l1Score ?? 0, event.dialogScore ?? 0, event.userMessage ?? null);
+    }
+    getSessionEvents(sessionId) {
+        return this.db.prepare('SELECT * FROM session_events WHERE session_id = ? ORDER BY created_at ASC').all(sessionId);
     }
     getUnprocessedEvents() {
-        const rows = this.db.prepare('SELECT id, session_id, tool, command, exit_code, stderr, duration_ms, created_at FROM events WHERE processed = 0 ORDER BY created_at ASC').all();
-        return rows.map(r => ({ id: r.id, sessionId: r.session_id, tool: r.tool, command: r.command, exitCode: r.exit_code, stderr: r.stderr, durationMs: r.duration_ms, createdAt: r.created_at }));
+        return this.db.prepare('SELECT * FROM session_events WHERE processed = 0 ORDER BY created_at ASC').all();
     }
     markEventsProcessed(ids) {
         if (ids.length === 0)
             return;
         const placeholders = ids.map(() => '?').join(',');
-        this.db.prepare(`UPDATE events SET processed = 1 WHERE id IN (${placeholders})`).run(...ids);
+        this.db.prepare(`UPDATE session_events SET processed = 1 WHERE id IN (${placeholders})`).run(...ids);
     }
-    cleanupExpired() {
+    eventWindowExists(tool, command, windowMs = 5 * 60 * 1000) {
+        const since = Date.now() - windowMs;
+        if (command) {
+            const row = this.db.prepare('SELECT 1 FROM session_events WHERE tool = ? AND command = ? AND created_at > ? LIMIT 1').get(tool, command, since);
+            return row !== undefined;
+        }
+        const row = this.db.prepare('SELECT 1 FROM session_events WHERE tool = ? AND command IS NULL AND created_at > ? LIMIT 1').get(tool, since);
+        return row !== undefined;
+    }
+    // ── Session CRUD ─────────────────────────────────
+    createSession(id, projectRoot, task = '') {
+        this.db.prepare(`
+      INSERT INTO sessions (id, project_root, task, status, created_at)
+      VALUES (?, ?, ?, 'active', ?)
+    `).run(id, projectRoot, task, Date.now());
+        console.log('[MemoryStore] Session created', { id, project: projectRoot, task });
+    }
+    closeSession(id) {
         const now = Date.now();
-        const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
-        this.db.prepare('DELETE FROM events WHERE processed = 1 AND created_at < ?').run(sevenDaysAgo);
-        // TTL soft-delete
-        const expired = this.db.prepare("UPDATE memories SET status = 'expired' WHERE expires_at IS NOT NULL AND expires_at < ? AND status != 'expired'").run(now);
-        // Low-quality pending cleanup
-        const fourteenDaysAgo = now - 14 * 24 * 60 * 60 * 1000;
-        const lowQuality = this.db.prepare("DELETE FROM memories WHERE status = 'pending' AND confidence < 0.4 AND created_at < ?").run(fourteenDaysAgo);
-        // Old pending → rejected
-        this.db.prepare("UPDATE memories SET status = 'rejected' WHERE status = 'pending' AND created_at < ?").run(fourteenDaysAgo);
-        // Hard-delete expired after 30 days
-        const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1000;
-        this.db.prepare("DELETE FROM memories WHERE status = 'expired' AND created_at < ?").run(thirtyDaysAgo);
-        this.db.prepare("DELETE FROM memories WHERE status = 'rejected' AND created_at < ?").run(thirtyDaysAgo);
-        return { expired: expired.changes, lowQuality: lowQuality.changes };
+        this.db.prepare(`
+      UPDATE sessions SET status = 'closed', closed_at = ?
+      WHERE id = ? AND status = 'active'
+    `).run(now, id);
+        console.log('[MemoryStore] Session closed', { id });
     }
-    cleanupLowQuality() {
-        // Remove pending rule-engine memories with low confidence (pre-fix garbage)
-        const result = this.db.prepare("DELETE FROM memories WHERE status = 'pending' AND source = 'rule_engine' AND confidence < 0.6").run();
-        return { removed: result.changes };
+    getSession(id) {
+        return this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) ?? null;
+    }
+    getActiveSessions() {
+        return this.db.prepare("SELECT * FROM sessions WHERE status = 'active' ORDER BY created_at DESC").all();
     }
-    migrateSchema() {
-        // Update CHECK constraint to accept new category names
-        const sql = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='memories'").get();
-        if (sql && (!sql.sql.includes('procedural') || !sql.sql.includes('expired'))) {
-            this.db.pragma('writable_schema = ON');
-            let newSql = sql.sql;
-            newSql = newSql.replace("category TEXT NOT NULL CHECK(category IN ('mcp_correction','project_knowledge','failure_lesson'))", "category TEXT NOT NULL CHECK(category IN ('procedural','semantic','episodic','failure_lesson','mcp_correction','project_knowledge'))");
-            newSql = newSql.replace("status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','approved','rejected'))", "status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','approved','rejected','expired'))");
-            this.db.prepare("UPDATE sqlite_master SET sql = ? WHERE type='table' AND name='memories'").run(newSql);
-            this.db.pragma('writable_schema = OFF');
+    updateSessionStats(id, stats) {
+        const sets = [];
+        const vals = [];
+        if (stats.tool_count !== undefined) {
+            sets.push('tool_count = ?');
+            vals.push(stats.tool_count);
         }
-        // Add access tracking and TTL columns
-        try {
-            this.db.exec('ALTER TABLE memories ADD COLUMN access_count INTEGER DEFAULT 0');
+        if (stats.error_count !== undefined) {
+            sets.push('error_count = ?');
+            vals.push(stats.error_count);
         }
-        catch { }
-        try {
-            this.db.exec('ALTER TABLE memories ADD COLUMN last_accessed_at INTEGER');
+        if (sets.length === 0)
+            return;
+        vals.push(id);
+        this.db.prepare(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+    }
+    getZombieSessions(maxAgeHours = 24) {
+        const cutoff = Date.now() - maxAgeHours * 60 * 60 * 1000;
+        return this.db.prepare("SELECT * FROM sessions WHERE status = 'active' AND created_at < ?").all(cutoff);
+    }
+    // ── Observation CRUD ─────────────────────────────
+    addObservation(obs) {
+        const id = obs.id ?? `obs:${Date.now()}:${randomUUID().slice(0, 8)}`;
+        const now = obs.timestamp ?? Date.now();
+        this.db.prepare(`
+      INSERT INTO observations
+        (id, session_id, project, type, title, narrative, facts, files, tools, concepts,
+         importance, confidence, source_event_ids, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, obs.sessionId, obs.project ?? '', obs.type, obs.title, obs.narrative ?? '', JSON.stringify(obs.facts ?? []), JSON.stringify(obs.files ?? []), JSON.stringify(obs.tools ?? []), JSON.stringify(obs.concepts ?? []), obs.importance ?? 5, obs.confidence ?? 0.5, JSON.stringify(obs.sourceEventIds ?? []), now);
+        // Insert concept junction rows
+        if (obs.concepts && obs.concepts.length > 0) {
+            const insertConcept = this.db.prepare('INSERT OR IGNORE INTO observation_concepts (observation_id, concept) VALUES (?, ?)');
+            for (const concept of obs.concepts) {
+                insertConcept.run(id, concept);
+            }
         }
-        catch { }
-        try {
-            this.db.exec('ALTER TABLE memories ADD COLUMN expires_at INTEGER');
+        console.log('[MemoryStore] Observation added', {
+            id, sessionId: obs.sessionId, type: obs.type, conceptCount: obs.concepts?.length ?? 0,
+        });
+        return this.getObservation(id);
+    }
+    getObservation(id) {
+        return this.db.prepare('SELECT * FROM observations WHERE id = ?').get(id) ?? null;
+    }
+    listObservations(filter) {
+        const conditions = [];
+        const vals = [];
+        if (filter?.sessionId) {
+            conditions.push('o.session_id = ?');
+            vals.push(filter.sessionId);
+        }
+        if (filter?.project) {
+            conditions.push('o.project = ?');
+            vals.push(filter.project);
+        }
+        if (filter?.type) {
+            conditions.push('o.type = ?');
+            vals.push(filter.type);
+        }
+        if (filter?.memoryId !== undefined) {
+            if (filter.memoryId === null) {
+                conditions.push('o.memory_id IS NULL');
+            }
+            else {
+                conditions.push('o.memory_id = ?');
+                vals.push(filter.memoryId);
+            }
+        }
+        let sql = 'SELECT o.* FROM observations o';
+        if (filter?.concept) {
+            sql += ' JOIN observation_concepts oc ON o.id = oc.observation_id';
+            conditions.push('oc.concept = ?');
+            vals.push(filter.concept);
         }
-        catch { }
-        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_access ON memories(access_count, last_accessed_at)');
-        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at) WHERE expires_at IS NOT NULL');
+        if (conditions.length > 0) {
+            sql += ' WHERE ' + conditions.join(' AND ');
+        }
+        sql += ' ORDER BY o.timestamp DESC';
+        if (filter?.limit) {
+            sql += ' LIMIT ?';
+            vals.push(filter.limit);
+        }
+        return this.db.prepare(sql).all(...vals);
     }
-    countByStatus(status) {
-        const row = this.db.prepare('SELECT COUNT(*) as c FROM memories WHERE status = ?').get(status);
+    getObservationsByConcept(concept, limit = 50) {
+        return this.listObservations({ concept, limit });
+    }
+    countObservationsByConcept(concept) {
+        const row = this.db.prepare(`
+      SELECT COUNT(DISTINCT o.id) as c
+      FROM observations o
+      JOIN observation_concepts oc ON o.id = oc.observation_id
+      WHERE oc.concept = ?
+    `).get(concept);
         return row?.c ?? 0;
     }
-    // --- Dedup helpers ---
-    eventWindowExists(tool, command, windowMs = 5 * 60 * 1000) {
-        const since = Date.now() - windowMs;
-        if (command) {
-            const row = this.db.prepare('SELECT 1 FROM events WHERE tool = ? AND command = ? AND created_at > ? LIMIT 1').get(tool, command, since);
-            return row !== undefined;
+    getConceptsForObservation(obsId) {
+        const rows = this.db.prepare('SELECT concept FROM observation_concepts WHERE observation_id = ?').all(obsId);
+        return rows.map(r => r.concept);
+    }
+    linkObservationToMemory(obsId, memoryId) {
+        this.db.prepare('UPDATE observations SET memory_id = ? WHERE id = ?').run(memoryId, obsId);
+    }
+    getUnconsolidatedObservations(project, minImportance = 5) {
+        return this.db.prepare(`
+      SELECT * FROM observations
+      WHERE project = ? AND memory_id IS NULL AND importance >= ?
+      ORDER BY timestamp DESC
+    `).all(project, minImportance);
+    }
+    /** Get concept clusters from unconsolidated observations, grouped by concept with session counts */
+    getClusterCandidates(project, minObservations = 3, minSessions = 2) {
+        const rows = this.db.prepare(`
+      SELECT
+        oc.concept,
+        COUNT(DISTINCT o.id) as observation_count,
+        COUNT(DISTINCT o.session_id) as session_count,
+        GROUP_CONCAT(DISTINCT o.id) as observation_ids
+      FROM observation_concepts oc
+      JOIN observations o ON o.id = oc.observation_id
+      WHERE o.project = ? AND o.memory_id IS NULL AND o.importance >= 5
+      GROUP BY oc.concept
+      HAVING observation_count >= ? AND session_count >= ?
+      ORDER BY observation_count DESC
+      LIMIT 8
+    `).all(project, minObservations, minSessions);
+        return rows.map(r => ({
+            concept: r.concept,
+            observationCount: r.observation_count,
+            sessionCount: r.session_count,
+            observationIds: r.observation_ids ? r.observation_ids.split(',') : [],
+        }));
+    }
+    // ── Signals ──────────────────────────────────────
+    recordSignals(signals) {
+        const insert = this.db.prepare(`
+      INSERT OR IGNORE INTO signals (id, session_id, type, strength, source_event_ids, payload, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const s of signals) {
+            insert.run(s.id, s.sessionId, s.type, s.strength, JSON.stringify(s.sourceEventIds), JSON.stringify(s.payload), s.timestamp);
+        }
+        if (signals.length > 0) {
+            console.log('[MemoryStore] Signals recorded', { count: signals.length, sessionId: signals[0].sessionId });
         }
-        const row = this.db.prepare('SELECT 1 FROM events WHERE tool = ? AND command IS NULL AND created_at > ? LIMIT 1').get(tool, since);
-        return row !== undefined;
+    }
+    getSessionSignals(sessionId) {
+        return this.db.prepare('SELECT * FROM signals WHERE session_id = ? ORDER BY timestamp ASC').all(sessionId);
+    }
+    // ── Evidence ─────────────────────────────────────
+    addEvidence(ev) {
+        const id = ev.id ?? `ev:${Date.now()}:${randomUUID().slice(0, 8)}`;
+        this.db.prepare(`
+      INSERT INTO evidence (id, memory_id, type, weight, source_observation_ids, summary, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(id, ev.memoryId, ev.type, ev.weight, JSON.stringify(ev.sourceObservationIds), ev.summary, ev.timestamp ?? Date.now());
+        return id;
+    }
+    getEvidenceForMemory(memoryId) {
+        return this.db.prepare('SELECT * FROM evidence WHERE memory_id = ? ORDER BY timestamp DESC').all(memoryId);
+    }
+    // ── Access Log ───────────────────────────────────
+    recordAccess(memoryId, accessType, sessionId) {
+        const id = `acc:${Date.now()}:${randomUUID().slice(0, 8)}`;
+        this.db.prepare(`
+      INSERT INTO access_log (id, memory_id, access_type, session_id, timestamp)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(id, memoryId, accessType, sessionId ?? null, Date.now());
     }
     incrementAccess(id) {
-        this.db.prepare('UPDATE memories SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?').run(Date.now(), id);
+        this.db.prepare(`
+      UPDATE memories SET access_count = access_count + 1,
+        last_reinforced_at = COALESCE(last_reinforced_at, ?),
+        updated_at = ?
+      WHERE id = ?
+    `).run(Date.now(), Date.now(), id);
+    }
+    // ── Memory History ───────────────────────────────
+    recordHistory(entry) {
+        const id = `hist:${Date.now()}:${randomUUID().slice(0, 8)}`;
+        this.db.prepare(`
+      INSERT INTO memory_history (id, memory_id, event, old_content, new_content,
+        old_strength, new_strength, reason, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, entry.memoryId, entry.event, entry.oldContent ?? null, entry.newContent ?? null, entry.oldStrength ?? null, entry.newStrength ?? null, entry.reason ?? '', Date.now());
+    }
+    getVersionChain(id) {
+        // Walk supersedes chain to find root, then collect all versions
+        let current = this.get(id);
+        if (!current)
+            return [];
+        // Walk backward to find root (oldest version)
+        const visited = new Set();
+        while (current?.supersedes && !visited.has(current.id)) {
+            visited.add(current.id);
+            const prev = this.get(current.supersedes);
+            if (!prev)
+                break;
+            current = prev;
+        }
+        // Collect all versions forward via superseded_by
+        const chain = [];
+        const rootId = current?.id;
+        if (!rootId)
+            return [];
+        let node = this.get(rootId);
+        const collected = new Set();
+        while (node && !collected.has(node.id)) {
+            collected.add(node.id);
+            chain.push(node);
+            node = node.superseded_by ? this.get(node.superseded_by) : null;
+        }
+        return chain.sort((a, b) => a.version - b.version);
+    }
+    getMemoryHistory(memoryId) {
+        return this.db.prepare('SELECT * FROM memory_history WHERE memory_id = ? ORDER BY created_at DESC').all(memoryId);
+    }
+    // ── Retention ────────────────────────────────────
+    upsertRetentionScore(memoryId, data) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO retention_scores
+        (memory_id, score, salience, temporal_decay, reinforcement_boost,
+         last_accessed, access_count, computed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(memoryId, data.score, data.salience, data.temporal_decay, data.reinforcement_boost, data.last_accessed ?? null, data.access_count ?? 0, Date.now());
+    }
+    getColdRetentionScores(threshold) {
+        return this.db.prepare('SELECT memory_id, score FROM retention_scores WHERE score < ? ORDER BY score ASC').all(threshold);
+    }
+    getRetentionScore(memoryId) {
+        return this.db.prepare('SELECT * FROM retention_scores WHERE memory_id = ?').get(memoryId) ?? null;
+    }
+    computeRetentionScore(memory) {
+        const ageDays = (Date.now() - memory.created_at) / 86400000;
+        const lambdaBase = 0.05;
+        const lambda = lambdaBase / (1 + memory.reinforce_count);
+        const sourceImportance = {
+            manual: 1.0, consolidation: 0.8, auto: 0.6, rule_engine: 0.4,
+        };
+        const salience = memory.confidence * (sourceImportance[memory.source] ?? 0.5);
+        const temporalDecay = Math.exp(-lambda * Math.max(ageDays, 0));
+        const reinforcementBoost = 1 + 0.1 * Math.min(memory.access_count, 10);
+        const score = salience * temporalDecay * reinforcementBoost;
+        return { score, salience, temporalDecay, reinforcementBoost };
+    }
+    runRetentionSweep(project) {
+        const now = Date.now();
+        const fourteenDaysAgo = now - 14 * 24 * 60 * 60 * 1000;
+        // Load candidates: active/approved/pending memories
+        const candidates = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE status IN ('active','approved','pending')
+        AND superseded_by IS NULL
+        AND (expires_at IS NULL OR expires_at > ?)
+      ORDER BY updated_at ASC
+    `).all(now);
+        let kept = 0, downgraded = 0, expired = 0;
+        for (const mem of candidates) {
+            // Explicit expires_at check (takes priority)
+            if (mem.expires_at != null && mem.expires_at < now) {
+                this.db.prepare("UPDATE memories SET status = 'expired' WHERE id = ?").run(mem.id);
+                this.recordHistory({ memoryId: mem.id, event: 'EXPIRE', reason: 'explicit_ttl' });
+                expired++;
+                continue;
+            }
+            // Never accessed + old → direct expire
+            const accessCount = this.db.prepare('SELECT COUNT(*) as c FROM access_log WHERE memory_id = ?').get(mem.id).c;
+            const ageDays = (now - mem.created_at) / 86400000;
+            if (accessCount === 0 && ageDays > 90) {
+                this.db.prepare("UPDATE memories SET status = 'expired' WHERE id = ?").run(mem.id);
+                this.recordHistory({ memoryId: mem.id, event: 'EXPIRE', reason: 'never_accessed' });
+                expired++;
+                continue;
+            }
+            // Compute retention score
+            const retention = this.computeRetentionScore(mem);
+            this.upsertRetentionScore(mem.id, {
+                score: retention.score,
+                salience: retention.salience,
+                temporal_decay: retention.temporalDecay,
+                reinforcement_boost: retention.reinforcementBoost,
+                access_count: accessCount,
+            });
+            // Decision matrix
+            if (retention.score >= 0.6) {
+                this.db.prepare("UPDATE memories SET expires_at = ? WHERE id = ?").run(now + 30 * 24 * 60 * 60 * 1000, mem.id);
+                kept++;
+            }
+            else if (retention.score >= 0.3) {
+                this.db.prepare("UPDATE memories SET status = 'pending' WHERE id = ? AND status = 'active'").run(mem.id);
+                downgraded++;
+            }
+            else {
+                this.db.prepare("UPDATE memories SET status = 'expired' WHERE id = ?").run(mem.id);
+                this.recordHistory({ memoryId: mem.id, event: 'EXPIRE', reason: `retention_score_${retention.score.toFixed(2)}` });
+                expired++;
+            }
+        }
+        // Cleanup: pending + age > 14d → expired
+        const pendingExpired = this.db.prepare("UPDATE memories SET status = 'expired' WHERE status = 'pending' AND updated_at < ?").run(fourteenDaysAgo);
+        // Clean old processed events
+        const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+        const cleanedEvents = this.db.prepare('DELETE FROM session_events WHERE processed = 1 AND created_at < ?').run(sevenDaysAgo);
+        const total = { swept: candidates.length, kept, downgraded, expired: expired + pendingExpired.changes, cleanedEvents: cleanedEvents.changes };
+        console.log('[MemoryStore] Retention sweep complete', total);
+        return total;
     }
+    // ── TTL / Cleanup ────────────────────────────────
     setExpires(id, expiresAt) {
         this.db.prepare('UPDATE memories SET expires_at = ? WHERE id = ?').run(expiresAt, id);
     }
-    getSessionEvents(sessionId) {
-        const rows = this.db.prepare('SELECT id, session_id, tool, command, exit_code, stderr, duration_ms, created_at FROM events WHERE session_id = ? ORDER BY created_at ASC').all(sessionId);
-        return rows.map(r => ({ id: r.id, sessionId: r.session_id, tool: r.tool, command: r.command, exitCode: r.exit_code, stderr: r.stderr, durationMs: r.duration_ms, createdAt: r.created_at }));
+    cleanupExpired() {
+        const now = Date.now();
+        const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+        this.db.prepare('DELETE FROM session_events WHERE processed = 1 AND created_at < ?').run(sevenDaysAgo);
+        const expired = this.db.prepare("UPDATE memories SET status = 'expired' WHERE expires_at IS NOT NULL AND expires_at < ? AND status != 'expired'").run(now);
+        const fourteenDaysAgo = now - 14 * 24 * 60 * 60 * 1000;
+        const lowQuality = this.db.prepare("DELETE FROM memories WHERE status = 'pending' AND confidence < 0.4 AND created_at < ?").run(fourteenDaysAgo);
+        this.db.prepare("UPDATE memories SET status = 'expired' WHERE status = 'pending' AND created_at < ?").run(fourteenDaysAgo);
+        return { expired: expired.changes, lowQuality: lowQuality.changes };
+    }
+    cleanupLowQuality() {
+        const result = this.db.prepare("DELETE FROM memories WHERE status = 'pending' AND source = 'rule_engine' AND confidence < 0.6").run();
+        return { removed: result.changes };
     }
+    // ── Lifecycle ────────────────────────────────────
+    close() {
+        this.db.close();
+    }
+}
+// ── Helpers ────────────────────────────────────────────
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
 }
 //# sourceMappingURL=memory-store.js.map