sensorium-mcp 2.16.28 → 2.16.30

package/dist/memory.js

@@ -1,1360 +1,9 @@
-import BetterSqlite3 from "better-sqlite3";
-import { randomUUID } from "crypto";
-import { mkdirSync, statSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { log } from "./logger.js";
-import { cosineSimilarity } from "./openai.js";
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-function generateId(prefix) {
-    return `${prefix}_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
-}
-function nowISO() {
-    return new Date().toISOString();
-}
-function jsonOrNull(val) {
-    if (val === undefined || val === null)
-        return null;
-    return JSON.stringify(val);
-}
-function parseJsonArray(val) {
-    if (!val)
-        return [];
-    try {
-        return JSON.parse(val);
-    }
-    catch {
-        return [];
-    }
-}
-function parseJsonObject(val) {
-    if (!val)
-        return {};
-    try {
-        return JSON.parse(val);
-    }
-    catch {
-        return {};
-    }
-}
-// ─── Database Initialization ─────────────────────────────────────────────────
-const SCHEMA_VERSION = 5;
-// ─── Migrations ──────────────────────────────────────────────────────────────
 /**
- * Migration functions keyed by target schema version.
- * Each migration upgrades from version (key - 1) to version (key).
- * Add new migrations here when SCHEMA_VERSION is bumped.
+ * Memory subsystem — barrel re-export.
+ *
+ * All memory functionality lives in src/data/memory/ modules.
+ * This file re-exports everything so existing `import … from "./memory.js"`
+ * statements continue to work unchanged.
  */
-const MIGRATIONS = {
-    2: (db) => {
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS note_embeddings (
-        note_id    TEXT PRIMARY KEY,
-        embedding  BLOB NOT NULL,
-        model      TEXT NOT NULL DEFAULT 'text-embedding-3-small',
-        created_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_emb_note ON note_embeddings(note_id);
-    `);
-    },
-    3: (db) => {
-        // Add priority column: 0=normal, 1=notable, 2=high importance
-        // Use try/catch because new databases already have the column in SCHEMA_SQL
-        try {
-            db.exec(`ALTER TABLE semantic_notes ADD COLUMN priority INTEGER NOT NULL DEFAULT 0`);
-        }
-        catch {
-            // Column already exists — safe to ignore
-        }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_sem_priority ON semantic_notes(priority DESC) WHERE valid_to IS NULL`);
-    },
-    4: (db) => {
-        // Add thread_id column: NULL = global, number = thread-scoped
-        try {
-            db.exec(`ALTER TABLE semantic_notes ADD COLUMN thread_id INTEGER`);
-        }
-        catch {
-            // Column already exists — safe to ignore
-        }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_sem_thread ON semantic_notes(thread_id) WHERE valid_to IS NULL`);
-        // Backfill thread_id from source episodes
-        const notes = db.prepare(`SELECT note_id, source_episodes FROM semantic_notes WHERE thread_id IS NULL`).all();
-        const update = db.prepare(`UPDATE semantic_notes SET thread_id = ? WHERE note_id = ?`);
-        let backfilled = 0;
-        for (const note of notes) {
-            let episodeIds = [];
-            try {
-                episodeIds = JSON.parse(note.source_episodes ?? "[]");
-            }
-            catch { /* ignore */ }
-            if (episodeIds.length === 0)
-                continue;
-            const placeholders = episodeIds.map(() => "?").join(",");
-            const rows = db.prepare(`SELECT thread_id, COUNT(*) as cnt FROM episodes WHERE episode_id IN (${placeholders}) GROUP BY thread_id ORDER BY cnt DESC LIMIT 1`).all(...episodeIds);
-            if (rows.length > 0 && rows[0].thread_id != null) {
-                update.run(rows[0].thread_id, note.note_id);
-                backfilled++;
-            }
-        }
-        if (backfilled > 0) {
-            log.info(`[migration-4] Backfilled thread_id on ${backfilled}/${notes.length} existing notes.`);
-        }
-    },
-    5: (db) => {
-        // Widen CHECK constraints on episodes table to include 'operator_reaction'
-        // type and 'reaction' modality. SQLite does not support ALTER COLUMN, so we
-        // must recreate the table.
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS episodes_new (
-        episode_id     TEXT PRIMARY KEY,
-        session_id     TEXT NOT NULL,
-        thread_id      INTEGER NOT NULL,
-        timestamp      TEXT NOT NULL,
-        type           TEXT NOT NULL CHECK(type IN ('operator_message','agent_action','system_event','operator_reaction')),
-        modality       TEXT NOT NULL CHECK(modality IN ('text','voice','photo','video_note','document','mixed','reaction')),
-        content        TEXT NOT NULL,
-        topic_tags     TEXT,
-        importance     REAL NOT NULL DEFAULT 0.5,
-        consolidated   INTEGER DEFAULT 0,
-        accessed_count INTEGER DEFAULT 0,
-        last_accessed  TEXT,
-        created_at     TEXT NOT NULL
-      );
-      INSERT INTO episodes_new SELECT * FROM episodes;
-      DROP TABLE episodes;
-      ALTER TABLE episodes_new RENAME TO episodes;
-      CREATE INDEX IF NOT EXISTS idx_ep_thread_time ON episodes(thread_id, timestamp DESC);
-      CREATE INDEX IF NOT EXISTS idx_ep_importance ON episodes(importance DESC);
-      CREATE INDEX IF NOT EXISTS idx_ep_uncons ON episodes(consolidated) WHERE consolidated = 0;
-    `);
-    },
-};
-/**
- * Read the current schema version from the database.
- * Returns 1 if no version is recorded (initial schema).
- */
-function getCurrentSchemaVersion(db) {
-    try {
-        const row = db
-            .prepare("SELECT MAX(version) as v FROM schema_version")
-            .get();
-        return row?.v ?? 1;
-    }
-    catch {
-        // Table may not exist yet on first run
-        return 0;
-    }
-}
-/**
- * Run any pending migrations sequentially from the current stored version
- * up to SCHEMA_VERSION.  Each migration runs inside a transaction.
- */
-function runMigrations(db) {
-    const currentVersion = getCurrentSchemaVersion(db);
-    log.info(`[memory] Current schema version: ${currentVersion}, target: ${SCHEMA_VERSION}`);
-    for (let v = currentVersion + 1; v <= SCHEMA_VERSION; v++) {
-        const migration = MIGRATIONS[v];
-        if (migration) {
-            try {
-                // Run DDL migrations outside transactions — SQLite DDL + transactions
-                // can have subtle issues in WAL mode with better-sqlite3.
-                migration(db);
-                db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(v, nowISO());
-                log.info(`[memory] Migrated schema to version ${v}`);
-            }
-            catch (err) {
-                log.error(`[memory] Migration ${v} FAILED: ${err instanceof Error ? err.message : String(err)}`);
-                throw err;
-            }
-        }
-    }
-}
-const SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS episodes (
-  episode_id     TEXT PRIMARY KEY,
-  session_id     TEXT NOT NULL,
-  thread_id      INTEGER NOT NULL,
-  timestamp      TEXT NOT NULL,
-  type           TEXT NOT NULL CHECK(type IN ('operator_message','agent_action','system_event','operator_reaction')),
-  modality       TEXT NOT NULL CHECK(modality IN ('text','voice','photo','video_note','document','mixed','reaction')),
-  content        TEXT NOT NULL,
-  topic_tags     TEXT,
-  importance     REAL NOT NULL DEFAULT 0.5,
-  consolidated   INTEGER DEFAULT 0,
-  accessed_count INTEGER DEFAULT 0,
-  last_accessed  TEXT,
-  created_at     TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_ep_thread_time ON episodes(thread_id, timestamp DESC);
-CREATE INDEX IF NOT EXISTS idx_ep_importance ON episodes(importance DESC);
-CREATE INDEX IF NOT EXISTS idx_ep_uncons ON episodes(consolidated) WHERE consolidated = 0;
-
-CREATE TABLE IF NOT EXISTS semantic_notes (
-  note_id         TEXT PRIMARY KEY,
-  type            TEXT NOT NULL CHECK(type IN ('fact','preference','pattern','entity','relationship')),
-  content         TEXT NOT NULL,
-  keywords        TEXT NOT NULL,
-  confidence      REAL NOT NULL DEFAULT 0.5,
-  source_episodes TEXT,
-  linked_notes    TEXT,
-  link_reasons    TEXT,
-  valid_from      TEXT NOT NULL,
-  valid_to        TEXT,
-  superseded_by   TEXT,
-  access_count    INTEGER DEFAULT 0,
-  last_accessed   TEXT,
-  priority        INTEGER NOT NULL DEFAULT 0,
-  thread_id       INTEGER,
-  created_at      TEXT NOT NULL,
-  updated_at      TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_sem_type ON semantic_notes(type);
-CREATE INDEX IF NOT EXISTS idx_sem_conf ON semantic_notes(confidence DESC);
-CREATE INDEX IF NOT EXISTS idx_sem_valid ON semantic_notes(valid_to) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS idx_sem_priority ON semantic_notes(priority DESC) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS idx_sem_thread ON semantic_notes(thread_id) WHERE valid_to IS NULL;
-
-CREATE TABLE IF NOT EXISTS procedures (
-  procedure_id       TEXT PRIMARY KEY,
-  name               TEXT NOT NULL,
-  type               TEXT NOT NULL CHECK(type IN ('workflow','habit','tool_pattern','template')),
-  description        TEXT NOT NULL,
-  steps              TEXT,
-  trigger_conditions TEXT,
-  success_rate       REAL DEFAULT 0.5,
-  times_executed     INTEGER DEFAULT 0,
-  last_executed_at   TEXT,
-  learned_from       TEXT,
-  corrections        TEXT,
-  related_procedures TEXT,
-  confidence         REAL DEFAULT 0.5,
-  created_at         TEXT NOT NULL,
-  updated_at         TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_proc_name ON procedures(name);
-CREATE INDEX IF NOT EXISTS idx_proc_type ON procedures(type);
-
-CREATE TABLE IF NOT EXISTS meta_topic_index (
-  topic            TEXT PRIMARY KEY,
-  semantic_count   INTEGER DEFAULT 0,
-  procedural_count INTEGER DEFAULT 0,
-  last_updated     TEXT,
-  avg_confidence   REAL DEFAULT 0.5,
-  total_accesses   INTEGER DEFAULT 0
-);
-
-CREATE TABLE IF NOT EXISTS meta_consolidation_log (
-  id                  INTEGER PRIMARY KEY AUTOINCREMENT,
-  run_at              TEXT NOT NULL,
-  episodes_processed  INTEGER,
-  notes_created       INTEGER,
-  duration_ms         INTEGER
-);
-
-CREATE TABLE IF NOT EXISTS voice_signatures (
-  id             INTEGER PRIMARY KEY AUTOINCREMENT,
-  episode_id     TEXT NOT NULL,
-  emotion        TEXT,
-  arousal        REAL,
-  dominance      REAL,
-  valence        REAL,
-  speech_rate    REAL,
-  mean_pitch_hz  REAL,
-  pitch_std_hz   REAL,
-  jitter         REAL,
-  shimmer        REAL,
-  hnr_db         REAL,
-  audio_events   TEXT,
-  duration_sec   REAL,
-  created_at     TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_voice_ep ON voice_signatures(episode_id);
-CREATE INDEX IF NOT EXISTS idx_voice_time ON voice_signatures(created_at DESC);
-
-CREATE TABLE IF NOT EXISTS note_embeddings (
-  note_id    TEXT PRIMARY KEY,
-  embedding  BLOB NOT NULL,
-  model      TEXT NOT NULL DEFAULT 'text-embedding-3-small',
-  created_at TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_emb_note ON note_embeddings(note_id);
-
-CREATE TABLE IF NOT EXISTS schema_version (
-  version     INTEGER PRIMARY KEY,
-  applied_at  TEXT NOT NULL
-);
-`;
-export function initMemoryDb() {
-    const dbDir = join(homedir(), ".remote-copilot-mcp");
-    mkdirSync(dbDir, { recursive: true });
-    const dbPath = join(dbDir, "memory.db");
-    const db = new BetterSqlite3(dbPath);
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
-    // Create all tables
-    db.exec(SCHEMA_SQL);
-    // Record base schema version for brand-new databases only
-    const versionCount = db.prepare("SELECT COUNT(*) as cnt FROM schema_version").get().cnt;
-    if (versionCount === 0) {
-        // New database — record version 1 as the base, then run all migrations up to SCHEMA_VERSION
-        db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (1, ?)").run(nowISO());
-    }
-    else {
-        // Repair: older code may have recorded SCHEMA_VERSION prematurely without running migrations.
-        // Detect by checking if version 3 was recorded but the priority column is missing.
-        const hasV3 = db.prepare("SELECT version FROM schema_version WHERE version = 3").get();
-        if (hasV3) {
-            const cols = db.prepare("PRAGMA table_info(semantic_notes)").all();
-            const hasPriority = cols.some(c => c.name === "priority");
-            if (!hasPriority) {
-                // Version 3 was recorded but migration never ran — reset to version 2
-                db.prepare("DELETE FROM schema_version WHERE version >= 3").run();
-                log.warn("[memory] Repaired: schema_version was ahead of actual migrations, reset to v2");
-            }
-        }
-        const hasV4 = db.prepare("SELECT version FROM schema_version WHERE version = 4").get();
-        if (hasV4) {
-            const cols = db.prepare("PRAGMA table_info(semantic_notes)").all();
-            const hasThreadId = cols.some(c => c.name === "thread_id");
-            if (!hasThreadId) {
-                db.prepare("DELETE FROM schema_version WHERE version >= 4").run();
-                log.warn("[memory] Repaired: schema_version was ahead of actual migrations, reset to v3");
-            }
-        }
-    }
-    // Run any pending migrations (will upgrade from stored version to SCHEMA_VERSION)
-    runMigrations(db);
-    // Direct repair: ensure priority column exists regardless of migration state.
-    // This handles edge cases where migrations fail silently or the migration system
-    // recorded a version without actually applying the schema change.
-    {
-        const cols = db.prepare("PRAGMA table_info(semantic_notes)").all();
-        if (!cols.some(c => c.name === "priority")) {
-            log.info("[memory] Direct repair: adding missing priority column");
-            db.exec(`ALTER TABLE semantic_notes ADD COLUMN priority INTEGER NOT NULL DEFAULT 0`);
-            db.exec(`CREATE INDEX IF NOT EXISTS idx_sem_priority ON semantic_notes(priority DESC) WHERE valid_to IS NULL`);
-        }
-        if (!cols.some(c => c.name === "thread_id")) {
-            log.info("[memory] Direct repair: adding missing thread_id column");
-            db.exec(`ALTER TABLE semantic_notes ADD COLUMN thread_id INTEGER`);
-            db.exec(`CREATE INDEX IF NOT EXISTS idx_sem_thread ON semantic_notes(thread_id) WHERE valid_to IS NULL`);
-        }
-    }
-    return db;
-}
-// ─── Row → Interface mappers ─────────────────────────────────────────────────
-function rowToEpisode(row) {
-    return {
-        episodeId: row.episode_id,
-        sessionId: row.session_id,
-        threadId: row.thread_id,
-        timestamp: row.timestamp,
-        type: row.type,
-        modality: row.modality,
-        content: parseJsonObject(row.content),
-        topicTags: parseJsonArray(row.topic_tags),
-        importance: row.importance,
-        consolidated: row.consolidated === 1,
-        accessedCount: row.accessed_count,
-        lastAccessed: row.last_accessed ?? null,
-        createdAt: row.created_at,
-    };
-}
-function rowToSemanticNote(row) {
-    return {
-        noteId: row.note_id,
-        type: row.type,
-        content: row.content,
-        keywords: parseJsonArray(row.keywords),
-        confidence: row.confidence,
-        priority: row.priority ?? 0,
-        threadId: row.thread_id ?? null,
-        sourceEpisodes: parseJsonArray(row.source_episodes),
-        linkedNotes: parseJsonArray(row.linked_notes),
-        linkReasons: parseJsonObject(row.link_reasons),
-        validFrom: row.valid_from,
-        validTo: row.valid_to ?? null,
-        supersededBy: row.superseded_by ?? null,
-        accessCount: row.access_count,
-        lastAccessed: row.last_accessed ?? null,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function rowToProcedure(row) {
-    return {
-        procedureId: row.procedure_id,
-        name: row.name,
-        type: row.type,
-        description: row.description,
-        steps: parseJsonArray(row.steps),
-        triggerConditions: parseJsonArray(row.trigger_conditions),
-        successRate: row.success_rate,
-        timesExecuted: row.times_executed,
-        lastExecutedAt: row.last_executed_at ?? null,
-        learnedFrom: parseJsonArray(row.learned_from),
-        corrections: parseJsonArray(row.corrections),
-        relatedProcedures: parseJsonArray(row.related_procedures),
-        confidence: row.confidence,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function rowToTopicEntry(row) {
-    return {
-        topic: row.topic,
-        semanticCount: row.semantic_count,
-        proceduralCount: row.procedural_count,
-        lastUpdated: row.last_updated ?? null,
-        avgConfidence: row.avg_confidence,
-        totalAccesses: row.total_accesses,
-    };
-}
-// ─── Episodic Memory ─────────────────────────────────────────────────────────
-export function saveEpisode(db, episode) {
-    const id = generateId("ep");
-    const now = nowISO();
-    db.prepare(`INSERT INTO episodes
-       (episode_id, session_id, thread_id, timestamp, type, modality, content, topic_tags, importance, consolidated, accessed_count, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?)`).run(id, episode.sessionId, episode.threadId, now, episode.type, episode.modality, JSON.stringify(episode.content), jsonOrNull(episode.topicTags), episode.importance ?? 0.5, now);
-    return id;
-}
-export function getRecentEpisodes(db, threadId, limit = 20) {
-    const rows = db
-        .prepare(`SELECT * FROM episodes WHERE thread_id = ? ORDER BY timestamp DESC LIMIT ?`)
-        .all(threadId, limit);
-    return rows.map(rowToEpisode);
-}
-function getUnconsolidatedEpisodes(db, threadId, limit = 50) {
-    const rows = db
-        .prepare(`SELECT * FROM episodes WHERE thread_id = ? AND consolidated = 0 ORDER BY timestamp ASC LIMIT ?`)
-        .all(threadId, limit);
-    return rows.map(rowToEpisode);
-}
-function markConsolidated(db, episodeIds) {
-    if (episodeIds.length === 0)
-        return;
-    const stmt = db.prepare(`UPDATE episodes SET consolidated = 1 WHERE episode_id = ?`);
-    const txn = db.transaction(() => {
-        for (const id of episodeIds) {
-            stmt.run(id);
-        }
-    });
-    txn();
-}
-// ─── Semantic Memory ─────────────────────────────────────────────────────────
-export function saveSemanticNote(db, note) {
-    const id = generateId("sn");
-    const now = nowISO();
-    db.prepare(`INSERT INTO semantic_notes
-       (note_id, type, content, keywords, confidence, priority, thread_id, source_episodes, linked_notes, link_reasons, valid_from, access_count, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`).run(id, note.type, note.content, JSON.stringify(note.keywords), Math.max(0, Math.min(1, note.confidence ?? 0.5)), Math.max(0, Math.min(2, note.priority ?? 0)), note.threadId ?? null, jsonOrNull(note.sourceEpisodes), null, null, now, now, now);
-    // Update topic index for each keyword
-    updateTopicIndexForKeywords(db, note.keywords, "semantic");
-    return id;
-}
-export function searchSemanticNotes(db, query, options) {
-    const maxResults = options?.maxResults ?? 10;
-    const terms = query
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((t) => t.length > 1);
-    if (terms.length === 0)
-        return [];
-    // Build LIKE conditions: each term must match content OR keywords
-    // Escape SQL LIKE wildcards in search terms
-    const conditions = [];
-    const params = [];
-    for (const term of terms) {
-        const escaped = term.replace(/%/g, "\\%").replace(/_/g, "\\_");
-        conditions.push(`(LOWER(content) LIKE ? ESCAPE '\\' OR LOWER(keywords) LIKE ? ESCAPE '\\')`);
-        params.push(`%${escaped}%`, `%${escaped}%`);
-    }
-    let sql = `SELECT * FROM semantic_notes WHERE valid_to IS NULL AND superseded_by IS NULL AND (${conditions.join(" AND ")})`;
-    if (options?.types && options.types.length > 0) {
-        const placeholders = options.types.map(() => "?").join(",");
-        sql += ` AND type IN (${placeholders})`;
-        params.push(...options.types);
-    }
-    sql += ` ORDER BY confidence DESC, access_count DESC LIMIT ?`;
-    params.push(maxResults);
-    const rows = db.prepare(sql).all(...params);
-    // Update access counts
-    if (!options?.skipAccessTracking) {
-        const now = nowISO();
-        const updateStmt = db.prepare(`UPDATE semantic_notes SET access_count = access_count + 1, last_accessed = ? WHERE note_id = ?`);
-        const txn = db.transaction(() => {
-            for (const row of rows) {
-                updateStmt.run(now, row.note_id);
-            }
-        });
-        txn();
-    }
-    return rows.map(rowToSemanticNote);
-}
-export function searchSemanticNotesRanked(db, query, options) {
-    const maxResults = options?.maxResults ?? 10;
-    const minMatchRatio = options?.minMatchRatio ?? 0.4; // require at least 40% of terms to match
-    const terms = query.toLowerCase().split(/\\s+/).filter(t => t.length > 1);
-    if (terms.length === 0)
-        return [];
-    // Use OR to get broad recall
-    const conditions = [];
-    const params = [];
-    for (const term of terms) {
-        const escaped = term.replace(/%/g, "\\\\%").replace(/_/g, "\\\\_");
-        conditions.push(`(LOWER(content) LIKE ? ESCAPE '\\\\' OR LOWER(keywords) LIKE ? ESCAPE '\\\\')`);
-        params.push(`%${escaped}%`, `%${escaped}%`);
-    }
-    let sql = `SELECT * FROM semantic_notes WHERE valid_to IS NULL AND superseded_by IS NULL AND (${conditions.join(" OR ")})`;
-    // Thread filtering: show notes from this thread + global notes
-    if (options?.threadId !== undefined) {
-        sql += ` AND (thread_id IS NULL OR thread_id = ?)`;
-        params.push(options.threadId);
-    }
-    if (options?.types && options.types.length > 0) {
-        const placeholders = options.types.map(() => "?").join(",");
-        sql += ` AND type IN (${placeholders})`;
-        params.push(...options.types);
-    }
-    sql += ` ORDER BY confidence DESC, access_count DESC LIMIT ?`;
-    params.push(maxResults * 3); // fetch more to allow scoring/filtering
-    const rows = db.prepare(sql).all(...params);
-    const allNotes = rows.map(rowToSemanticNote);
-    // Score by how many terms match
-    const minMatches = Math.max(2, Math.ceil(terms.length * minMatchRatio));
-    const scored = allNotes.map(n => {
-        const text = (n.content + " " + n.keywords.join(" ")).toLowerCase();
-        let matchCount = 0;
-        for (const term of terms) {
-            if (text.includes(term))
-                matchCount++;
-        }
-        return { ...n, _matchCount: matchCount };
-    })
-        .filter(n => n._matchCount >= minMatches)
-        .sort((a, b) => {
-        if (b._matchCount !== a._matchCount)
-            return b._matchCount - a._matchCount;
-        return b.confidence - a.confidence;
-    })
-        .slice(0, maxResults);
-    const notes = scored;
-    // Update access counts
-    if (!options?.skipAccessTracking) {
-        const now = nowISO();
-        const updateStmt = db.prepare(`UPDATE semantic_notes SET access_count = access_count + 1, last_accessed = ? WHERE note_id = ?`);
-        db.transaction(() => {
-            for (const note of notes)
-                updateStmt.run(now, note.noteId);
-        })();
-    }
-    return notes;
-}
-export function getTopSemanticNotes(db, options) {
-    const limit = options?.limit ?? 10;
-    const sortBy = options?.sortBy ?? "confidence";
-    const validSortColumns = {
-        confidence: "confidence DESC",
-        access_count: "access_count DESC",
-        created_at: "created_at DESC",
-    };
-    const orderClause = validSortColumns[sortBy] ?? "confidence DESC";
-    let sql = `SELECT * FROM semantic_notes WHERE valid_to IS NULL AND superseded_by IS NULL`;
-    const params = [];
-    if (options?.type) {
-        sql += ` AND type = ?`;
-        params.push(options.type);
-    }
-    sql += ` ORDER BY ${orderClause} LIMIT ?`;
-    params.push(limit);
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(rowToSemanticNote);
-}
-export function updateSemanticNote(db, noteId, updates) {
-    const now = nowISO();
-    const setClauses = ["updated_at = ?"];
-    const params = [now];
-    if (updates.content !== undefined) {
-        setClauses.push("content = ?");
-        params.push(updates.content);
-    }
-    if (updates.confidence !== undefined) {
-        setClauses.push("confidence = ?");
-        params.push(updates.confidence);
-    }
-    if (updates.priority !== undefined) {
-        setClauses.push("priority = ?");
-        params.push(Math.max(0, Math.min(2, updates.priority)));
-    }
-    if (updates.keywords !== undefined) {
-        setClauses.push("keywords = ?");
-        params.push(JSON.stringify(updates.keywords));
-    }
-    if (updates.linkedNotes !== undefined) {
-        setClauses.push("linked_notes = ?");
-        params.push(JSON.stringify(updates.linkedNotes));
-    }
-    if (updates.linkReasons !== undefined) {
-        setClauses.push("link_reasons = ?");
-        params.push(JSON.stringify(updates.linkReasons));
-    }
-    params.push(noteId);
-    db.prepare(`UPDATE semantic_notes SET ${setClauses.join(", ")} WHERE note_id = ?`).run(...params);
-}
-export function supersedeNote(db, oldNoteId, newNote) {
-    // Inherit thread_id from the old note being superseded
-    const oldRow = db.prepare(`SELECT thread_id FROM semantic_notes WHERE note_id = ?`).get(oldNoteId);
-    const newId = saveSemanticNote(db, {
-        type: newNote.type,
-        content: newNote.content,
-        keywords: newNote.keywords,
-        confidence: newNote.confidence,
-        priority: newNote.priority,
-        threadId: oldRow?.thread_id ?? null,
-        sourceEpisodes: newNote.sourceEpisodes,
-    });
-    const now = nowISO();
-    db.prepare(`UPDATE semantic_notes SET superseded_by = ?, valid_to = ?, updated_at = ? WHERE note_id = ?`).run(newId, now, now, oldNoteId);
-    // Create bidirectional link: add old note to new note's linked_notes
-    const newRow = db.prepare(`SELECT linked_notes, link_reasons FROM semantic_notes WHERE note_id = ?`).get(newId);
-    const currentLinked = parseJsonArray(newRow?.linked_notes);
-    const currentReasons = parseJsonObject(newRow?.link_reasons);
-    if (!currentLinked.includes(oldNoteId)) {
-        currentLinked.push(oldNoteId);
-    }
-    currentReasons[oldNoteId] = "supersedes";
-    updateSemanticNote(db, newId, {
-        linkedNotes: currentLinked,
-        linkReasons: currentReasons,
-    });
-    return newId;
-}
-/**
- * Find existing active notes that potentially conflict with a newly saved note.
- * Matches notes with the same type and at least 2 keywords in common.
- * Returns matching notes (excluding the note itself) for the agent to review.
- */
-export function findPotentialConflicts(db, noteId) {
-    const row = db.prepare(`SELECT note_id, type, keywords FROM semantic_notes WHERE note_id = ?`).get(noteId);
-    if (!row)
-        return [];
-    const noteKeywords = row.keywords ? JSON.parse(row.keywords) : [];
-    if (noteKeywords.length < 2)
-        return [];
-    // Fetch all active notes of the same type (excluding this note and superseded ones)
-    const candidates = db.prepare(`SELECT * FROM semantic_notes
-     WHERE type = ? AND note_id != ? AND valid_to IS NULL AND superseded_by IS NULL`).all(row.type, noteId);
-    const lowerKeywords = new Set(noteKeywords.map(k => k.toLowerCase()));
-    return candidates
-        .filter(c => {
-        const cKeywords = c.keywords ? JSON.parse(c.keywords) : [];
-        const overlap = cKeywords.filter(k => lowerKeywords.has(k.toLowerCase())).length;
-        return overlap >= 2;
-    })
-        .map(rowToSemanticNote);
-}
-// ─── Procedural Memory ──────────────────────────────────────────────────────
-export function saveProcedure(db, proc) {
-    const id = generateId("pr");
-    const now = nowISO();
-    db.prepare(`INSERT INTO procedures
-       (procedure_id, name, type, description, steps, trigger_conditions, success_rate, times_executed, learned_from, corrections, related_procedures, confidence, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, 0.5, 0, ?, ?, ?, 0.5, ?, ?)`).run(id, proc.name, proc.type, proc.description, jsonOrNull(proc.steps), jsonOrNull(proc.triggerConditions), null, // learned_from
-    null, // corrections
-    null, // related_procedures
-    now, now);
-    // Update topic index based on procedure name words
-    const keywords = proc.name
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((w) => w.length > 2);
-    updateTopicIndexForKeywords(db, keywords, "procedural");
-    return id;
-}
-export function searchProcedures(db, query, maxResults = 10) {
-    const terms = query
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((t) => t.length > 1);
-    if (terms.length === 0)
-        return [];
-    const conditions = [];
-    const params = [];
-    for (const term of terms) {
-        const escaped = term.replace(/%/g, "\\%").replace(/_/g, "\\_");
-        conditions.push(`(LOWER(name) LIKE ? ESCAPE '\\' OR LOWER(description) LIKE ? ESCAPE '\\' OR LOWER(steps) LIKE ? ESCAPE '\\' OR LOWER(trigger_conditions) LIKE ? ESCAPE '\\')`);
-        params.push(`%${escaped}%`, `%${escaped}%`, `%${escaped}%`, `%${escaped}%`);
-    }
-    const sql = `SELECT * FROM procedures WHERE ${conditions.join(" OR ")} ORDER BY confidence DESC, success_rate DESC LIMIT ?`;
-    params.push(maxResults);
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(rowToProcedure);
-}
-export function updateProcedure(db, procedureId, updates) {
-    const now = nowISO();
-    const setClauses = ["updated_at = ?"];
-    const params = [now];
-    if (updates.description !== undefined) {
-        setClauses.push("description = ?");
-        params.push(updates.description);
-    }
-    if (updates.steps !== undefined) {
-        setClauses.push("steps = ?");
-        params.push(JSON.stringify(updates.steps));
-    }
-    if (updates.triggerConditions !== undefined) {
-        setClauses.push("trigger_conditions = ?");
-        params.push(JSON.stringify(updates.triggerConditions));
-    }
-    if (updates.successRate !== undefined) {
-        setClauses.push("success_rate = ?");
-        params.push(updates.successRate);
-    }
-    if (updates.timesExecuted !== undefined) {
-        setClauses.push("times_executed = ?");
-        params.push(updates.timesExecuted);
-    }
-    if (updates.corrections !== undefined) {
-        setClauses.push("corrections = ?");
-        params.push(JSON.stringify(updates.corrections));
-    }
-    if (updates.confidence !== undefined) {
-        setClauses.push("confidence = ?");
-        params.push(updates.confidence);
-    }
-    params.push(procedureId);
-    db.prepare(`UPDATE procedures SET ${setClauses.join(", ")} WHERE procedure_id = ?`).run(...params);
-}
-// ─── Meta Memory ─────────────────────────────────────────────────────────────
-function updateTopicIndexForKeywords(db, keywords, layer) {
-    const now = nowISO();
-    const col = layer === "semantic" ? "semantic_count" : "procedural_count";
-    const upsertStmt = db.prepare(`INSERT INTO meta_topic_index (topic, ${col}, last_updated)
-     VALUES (?, 1, ?)
-     ON CONFLICT(topic) DO UPDATE SET
-       ${col} = ${col} + 1,
-       last_updated = ?,
-       total_accesses = total_accesses + 1`);
-    const txn = db.transaction(() => {
-        for (const kw of keywords) {
-            const normalised = kw.toLowerCase().trim();
-            if (normalised.length > 1) {
-                upsertStmt.run(normalised, now, now);
-            }
-        }
-    });
-    txn();
-}
-function decrementTopicIndexForKeywords(db, keywords, layer) {
-    const col = layer === "semantic" ? "semantic_count" : "procedural_count";
-    const decrementStmt = db.prepare(`UPDATE meta_topic_index SET ${col} = MAX(${col} - 1, 0) WHERE topic = ?`);
-    const deleteStmt = db.prepare(`DELETE FROM meta_topic_index WHERE topic = ? AND semantic_count <= 0 AND procedural_count <= 0`);
-    const txn = db.transaction(() => {
-        for (const kw of keywords) {
-            const normalised = kw.toLowerCase().trim();
-            if (normalised.length > 1) {
-                decrementStmt.run(normalised);
-                deleteStmt.run(normalised);
-            }
-        }
-    });
-    txn();
-}
-export function getMemoryStatus(db, threadId) {
-    const totalEpisodes = db.prepare(`SELECT COUNT(*) as cnt FROM episodes WHERE thread_id = ?`).get(threadId).cnt;
-    const unconsolidatedEpisodes = db
-        .prepare(`SELECT COUNT(*) as cnt FROM episodes WHERE thread_id = ? AND consolidated = 0`)
-        .get(threadId).cnt;
-    const totalSemanticNotes = db.prepare(`SELECT COUNT(*) as cnt FROM semantic_notes WHERE valid_to IS NULL AND superseded_by IS NULL`).get().cnt;
-    const totalProcedures = db.prepare(`SELECT COUNT(*) as cnt FROM procedures`).get().cnt;
-    const totalVoiceSignatures = db.prepare(`SELECT COUNT(*) as cnt FROM voice_signatures`).get().cnt;
-    const lastConsolidationRow = db
-        .prepare(`SELECT run_at FROM meta_consolidation_log ORDER BY run_at DESC LIMIT 1`)
-        .get();
-    const topTopics = getTopicIndex(db).slice(0, 5);
-    // Database file size
-    const dbPath = join(homedir(), ".remote-copilot-mcp", "memory.db");
-    let dbSizeBytes = 0;
-    try {
-        dbSizeBytes = statSync(dbPath).size;
-    }
-    catch {
-        // file might not exist yet or be inaccessible
-    }
-    return {
-        totalEpisodes,
-        unconsolidatedEpisodes,
-        totalSemanticNotes,
-        totalProcedures,
-        totalVoiceSignatures,
-        lastConsolidation: lastConsolidationRow?.run_at ?? null,
-        topTopics,
-        dbSizeBytes,
-    };
-}
-export function getTopicIndex(db) {
-    const rows = db
-        .prepare(`SELECT * FROM meta_topic_index ORDER BY total_accesses DESC, semantic_count DESC LIMIT 50`)
-        .all();
-    return rows.map(rowToTopicEntry);
-}
-function logConsolidation(db, log) {
-    db.prepare(`INSERT INTO meta_consolidation_log
-       (run_at, episodes_processed, notes_created, duration_ms)
-     VALUES (?, ?, ?, ?)`).run(nowISO(), log.episodesProcessed, log.notesCreated, log.durationMs);
-}
-// ─── Voice Signatures ────────────────────────────────────────────────────────
-export function saveVoiceSignature(db, sig) {
-    db.prepare(`INSERT INTO voice_signatures
-       (episode_id, emotion, arousal, dominance, valence, speech_rate, mean_pitch_hz, pitch_std_hz, jitter, shimmer, hnr_db, audio_events, duration_sec, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sig.episodeId, sig.emotion ?? null, sig.arousal ?? null, sig.dominance ?? null, sig.valence ?? null, sig.speechRate ?? null, sig.meanPitchHz ?? null, sig.pitchStdHz ?? null, sig.jitter ?? null, sig.shimmer ?? null, sig.hnrDb ?? null, jsonOrNull(sig.audioEvents), sig.durationSec ?? null, nowISO());
-}
-function getVoiceBaseline(db, dayRange = 30) {
-    const cutoff = new Date(Date.now() - dayRange * 24 * 60 * 60 * 1000).toISOString();
-    const row = db
-        .prepare(`SELECT
-         AVG(arousal)       AS avg_arousal,
-         AVG(dominance)     AS avg_dominance,
-         AVG(valence)       AS avg_valence,
-         AVG(speech_rate)   AS avg_speech_rate,
-         AVG(mean_pitch_hz) AS avg_mean_pitch_hz,
-         AVG(pitch_std_hz)  AS avg_pitch_std_hz,
-         AVG(jitter)        AS avg_jitter,
-         AVG(shimmer)       AS avg_shimmer,
-         AVG(hnr_db)        AS avg_hnr_db,
-         COUNT(*)           AS sample_count
-       FROM voice_signatures
-       WHERE created_at >= ?`)
-        .get(cutoff);
-    if (!row || row.sample_count === 0)
-        return null;
-    return {
-        avgArousal: row.avg_arousal,
-        avgDominance: row.avg_dominance,
-        avgValence: row.avg_valence,
-        avgSpeechRate: row.avg_speech_rate,
-        avgMeanPitchHz: row.avg_mean_pitch_hz,
-        avgPitchStdHz: row.avg_pitch_std_hz,
-        avgJitter: row.avg_jitter,
-        avgShimmer: row.avg_shimmer,
-        avgHnrDb: row.avg_hnr_db,
-        sampleCount: row.sample_count,
-    };
-}
-// ─── Bootstrap ───────────────────────────────────────────────────────────────
-export function assembleBootstrap(db, threadId) {
-    const status = getMemoryStatus(db, threadId ?? 0);
-    const recentEpisodes = threadId ? getRecentEpisodes(db, threadId, 5) : [];
-    // Thread-aware Key Knowledge:
-    // 1. Thread-scoped notes (up to 6) for the current thread
-    // 2. Global profile notes (thread_id IS NULL, preference/pattern) up to 4
-    // If no threadId, show up to 10 null-thread notes (preferences/patterns first)
-    let sortedNotes;
-    if (threadId) {
-        const threadNotes = db
-            .prepare(`SELECT * FROM semantic_notes
-         WHERE valid_to IS NULL AND superseded_by IS NULL
-           AND thread_id = ?
-         ORDER BY access_count DESC, confidence DESC
-         LIMIT 6`)
-            .all(threadId);
-        const remaining = 10 - threadNotes.length;
-        const globalNotes = remaining > 0
-            ? db
-                .prepare(`SELECT * FROM semantic_notes
-             WHERE valid_to IS NULL AND superseded_by IS NULL
-               AND thread_id IS NULL
-               AND type IN ('preference', 'pattern')
-             ORDER BY access_count DESC, confidence DESC
-             LIMIT ?`)
-                .all(remaining)
-            : [];
-        sortedNotes = [...threadNotes, ...globalNotes].map(rowToSemanticNote);
-    }
-    else {
-        const nullThreadNotes = db
-            .prepare(`SELECT * FROM semantic_notes
-         WHERE valid_to IS NULL AND superseded_by IS NULL
-           AND thread_id IS NULL
-         ORDER BY
-           CASE WHEN type IN ('preference', 'pattern') THEN 0 ELSE 1 END,
-           access_count DESC, confidence DESC
-         LIMIT 10`)
-            .all();
-        sortedNotes = nullThreadNotes.map(rowToSemanticNote);
-    }
-    const activeProcedures = db
-        .prepare(`SELECT * FROM procedures ORDER BY times_executed DESC, confidence DESC LIMIT 5`)
-        .all();
-    const procedures = activeProcedures.map(rowToProcedure);
-    const baseline = getVoiceBaseline(db);
-    const lines = [];
-    lines.push("# Memory Briefing");
-    lines.push("");
-    // Status
-    lines.push("## Status");
-    lines.push(`- Episodes: ${status.totalEpisodes} (${status.unconsolidatedEpisodes} unconsolidated)`);
-    lines.push(`- Semantic notes: ${status.totalSemanticNotes}`);
-    lines.push(`- Procedures: ${status.totalProcedures}`);
-    lines.push(`- Voice signatures: ${status.totalVoiceSignatures}`);
-    if (status.lastConsolidation) {
-        lines.push(`- Last consolidation: ${status.lastConsolidation}`);
-    }
-    lines.push(`- DB size: ${(status.dbSizeBytes / 1024).toFixed(1)} KB`);
-    lines.push("");
-    // Recent episodes
-    if (recentEpisodes.length > 0) {
-        lines.push("## Recent Episodes");
-        for (const ep of recentEpisodes) {
-            const summary = typeof ep.content === "object" && ep.content !== null
-                ? ep.content.text ?? ep.content.caption ?? JSON.stringify(ep.content).slice(0, 120)
-                : String(ep.content).slice(0, 120);
-            lines.push(`- [${ep.type}/${ep.modality}] ${summary} (${ep.timestamp})`);
-        }
-        lines.push("");
-    }
-    // Key knowledge
-    if (sortedNotes.length > 0) {
-        lines.push("## Key Knowledge");
-        for (const note of sortedNotes) {
-            const savedDate = note.createdAt ? note.createdAt.slice(0, 10) : 'unknown';
-            lines.push(`- **[${note.type}]** ${note.content} (conf: ${note.confidence.toFixed(2)}, accessed: ${note.accessCount}x, saved: ${savedDate})`);
-        }
-        lines.push("");
-    }
-    // Active procedures
-    if (procedures.length > 0) {
-        lines.push("## Active Procedures");
-        for (const proc of procedures) {
-            lines.push(`- **${proc.name}** (${proc.type}) — success: ${(proc.successRate * 100).toFixed(0)}%, used ${proc.timesExecuted}x`);
-            if (proc.steps.length > 0) {
-                lines.push(`  Steps: ${proc.steps.join(" → ")}`);
-            }
-        }
-        lines.push("");
-    }
-    // Voice baseline
-    if (baseline && baseline.sampleCount > 0) {
-        lines.push("## Voice Baseline (30d)");
-        lines.push(`- Samples: ${baseline.sampleCount}`);
-        if (baseline.avgValence !== null)
-            lines.push(`- Avg valence: ${baseline.avgValence.toFixed(2)}`);
-        if (baseline.avgArousal !== null)
-            lines.push(`- Avg arousal: ${baseline.avgArousal.toFixed(2)}`);
-        if (baseline.avgSpeechRate !== null)
-            lines.push(`- Avg speech rate: ${baseline.avgSpeechRate.toFixed(1)}`);
-        if (baseline.avgMeanPitchHz !== null)
-            lines.push(`- Avg pitch: ${baseline.avgMeanPitchHz.toFixed(1)} Hz`);
-        lines.push("");
-    }
-    // Topics
-    if (status.topTopics.length > 0) {
-        lines.push("## Top Topics");
-        for (const t of status.topTopics) {
-            lines.push(`- ${t.topic} (semantic: ${t.semanticCount}, procedural: ${t.proceduralCount})`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-/**
- * Compact memory refresh — a condensed briefing for injection during long sessions.
- * Much shorter than full bootstrap. Designed to re-ground the agent after context compaction.
- */
-export function assembleCompactRefresh(db, threadId) {
-    const topNotes = getTopSemanticNotes(db, { limit: 6, sortBy: "access_count" });
-    if (topNotes.length === 0)
-        return "";
-    const lines = [];
-    lines.push("## Memory Refresh");
-    for (const note of topNotes) {
-        lines.push(`- **[${note.type}]** ${note.content}`);
-    }
-    return lines.join("\n");
-}
-// ─── Intelligent Consolidation ───────────────────────────────────────────────
-// PRIVACY NOTE: This function sends conversation episode excerpts to OpenAI's
-// API for knowledge extraction and consolidation. Operators can disable this
-// by setting the environment variable CONSOLIDATION_ENABLED=false (or "0").
-export async function runIntelligentConsolidation(db, threadId, options) {
-    // Opt-out: allow operators to disable consolidation for privacy reasons
-    const consolidationEnabled = process.env.CONSOLIDATION_ENABLED;
-    if (consolidationEnabled === "false" || consolidationEnabled === "0") {
-        return {
-            episodesProcessed: 0,
-            notesCreated: 0,
-            durationMs: 0,
-            details: ["Consolidation disabled via CONSOLIDATION_ENABLED env var."],
-        };
-    }
-    const startMs = Date.now();
-    const maxEpisodes = options?.maxEpisodes ?? 30;
-    const dryRun = options?.dryRun ?? false;
-    const episodes = getUnconsolidatedEpisodes(db, threadId, maxEpisodes);
-    if (episodes.length === 0) {
-        return {
-            episodesProcessed: 0,
-            notesCreated: 0,
-            durationMs: Date.now() - startMs,
-            details: ["Nothing to consolidate."],
-        };
-    }
-    // Format episodes for the prompt
-    const episodesText = episodes
-        .map((ep, i) => {
-        const content = typeof ep.content === "object" && ep.content !== null
-            ? ep.content.text ?? ep.content.caption ?? JSON.stringify(ep.content)
-            : String(ep.content);
-        return `[${i + 1}] (${ep.type}/${ep.modality}, ${ep.timestamp}) ${content}`;
-    })
-        .join("\n");
-    // ── Contradiction detection: find existing notes related to these episodes ──
-    // Extract keywords from episodes to search for potentially conflicting notes
-    const episodeWords = episodesText.toLowerCase()
-        .replace(/[^a-z0-9\s]/g, " ")
-        .split(/\s+/)
-        .filter(w => w.length > 3);
-    const wordFreq = new Map();
-    const stopWords = new Set(["this", "that", "with", "from", "have", "been", "will", "would", "could", "should", "about", "there", "their", "which", "when", "what", "were", "they", "than", "then", "also", "just", "more", "some", "into", "over", "after", "before", "other", "very", "your", "here"]);
-    for (const w of episodeWords) {
-        if (!stopWords.has(w))
-            wordFreq.set(w, (wordFreq.get(w) ?? 0) + 1);
-    }
-    const topKeywords = [...wordFreq.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 12)
-        .map(([w]) => w);
-    let existingNotesSection = "";
-    if (topKeywords.length > 0) {
-        try {
-            const related = searchSemanticNotesRanked(db, topKeywords.join(" "), {
-                maxResults: 15,
-                skipAccessTracking: true,
-                minMatchRatio: 0.2, // broader recall for contradiction scan
-            });
-            if (related.length > 0) {
-                existingNotesSection = `\n\nExisting memory notes (potentially related):
-${related.map(n => `[${n.noteId}] (${n.type}, conf: ${n.confidence}) ${n.content}`).join("\n")}`;
-            }
-        }
-        catch (_) { /* non-fatal — proceed without existing notes */ }
-    }
-    const systemPrompt = `You are a memory consolidation agent. Analyze these conversation episodes and extract knowledge that should be remembered across sessions.
-
-Episodes:
-${episodesText}${existingNotesSection}
-
-Output a JSON object with:
-{
-  "notes": [
-    {
-      "type": "fact" | "preference" | "pattern" | "entity" | "relationship",
-      "content": "One clear sentence describing the knowledge",
-      "keywords": ["keyword1", "keyword2", "keyword3"],
-      "confidence": 0.0-1.0,
-      "priority": 0 | 1 | 2
-    }
-  ],
-  "supersede": [
-    {
-      "oldNoteId": "sn_xxx",
-      "reason": "Why the old note is outdated/contradicted",
-      "newContent": "Updated version of the knowledge",
-      "type": "fact",
-      "keywords": ["keyword1", "keyword2"],
-      "confidence": 0.8,
-      "priority": 0 | 1 | 2
-    }
-  ]
-}
-
-Rules:
-- Only extract information that would be useful in future sessions
-- Preferences are stronger signals than facts (confidence: 0.9)
-- Do not extract trivial/transient information
-- If the operator corrected the agent, extract the correction as a preference
-- Focus on: operator name, preferences, communication style, technical choices, project context
-- CRITICAL: Check existing notes for CONTRADICTIONS. If a new episode contradicts or updates an existing note, add a "supersede" entry. The new episodes represent MORE RECENT information.
-- Common contradictions: decisions changed, projects completed/abandoned, preferences updated, tools/tech switched
-- PRIORITY DETECTION: Infer priority from the operator's language and emotional investment:
-  - priority 2 (high importance): operator says "important", "crucial", "I really need", "don't forget", shows strong emotional investment, repeated emphasis
-  - priority 1 (notable): operator says "would be nice", "I'd like", "should", mentions something multiple times across conversations
-  - priority 0 (normal): default for routine facts, observations, patterns
-- Return {"notes": [], "supersede": []} if nothing notable`;
-    let notesCreated = 0;
-    const details = [];
-    try {
-        const apiKey = process.env.OPENAI_API_KEY;
-        if (!apiKey) {
-            throw new Error("OPENAI_API_KEY not set");
-        }
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 60_000);
-        try {
-            const response = await fetch("https://api.openai.com/v1/chat/completions", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${apiKey}`,
-                },
-                body: JSON.stringify({
-                    model: process.env.CONSOLIDATION_MODEL ?? "gpt-4o-mini",
-                    messages: [
-                        { role: "system", content: systemPrompt },
-                        { role: "user", content: "Extract knowledge from the episodes above." },
-                    ],
-                    response_format: { type: "json_object" },
-                }),
-                signal: controller.signal,
-            });
-            clearTimeout(timer);
-            if (!response.ok) {
-                const errText = await response.text().catch(() => response.statusText);
-                throw new Error(`OpenAI API error: ${response.status} ${errText}`);
-            }
-            const result = (await response.json());
-            const raw = result.choices?.[0]?.message?.content ?? "{}";
-            const parsed = JSON.parse(raw);
-            const extractedNotes = parsed.notes ?? [];
-            const supersedeActions = parsed.supersede ?? [];
-            const episodeIds = episodes.map((ep) => ep.episodeId);
-            if (!dryRun) {
-                for (const note of extractedNotes) {
-                    const validTypes = ["fact", "preference", "pattern", "entity", "relationship"];
-                    const noteType = validTypes.includes(note.type)
-                        ? note.type
-                        : "fact";
-                    saveSemanticNote(db, {
-                        type: noteType,
-                        content: note.content,
-                        keywords: Array.isArray(note.keywords) ? note.keywords : [],
-                        confidence: Math.max(0, Math.min(1, note.confidence ?? 0.5)),
-                        priority: Math.max(0, Math.min(2, note.priority ?? 0)),
-                        threadId: threadId,
-                        sourceEpisodes: episodeIds,
-                    });
-                    notesCreated++;
-                    details.push(`[${noteType}] ${note.content}`);
-                }
-                // Execute supersede actions — resolve contradictions with existing notes
-                let supersededCount = 0;
-                for (const action of supersedeActions) {
-                    if (!action.oldNoteId || !action.newContent)
-                        continue;
-                    // Verify old note exists and is still active
-                    const oldNote = db.prepare(`SELECT note_id FROM semantic_notes WHERE note_id = ? AND valid_to IS NULL AND superseded_by IS NULL`).get(action.oldNoteId);
-                    if (!oldNote) {
-                        details.push(`[skip-supersede] ${action.oldNoteId} not found or already superseded`);
-                        continue;
-                    }
-                    try {
-                        const validTypes = ["fact", "preference", "pattern", "entity", "relationship"];
-                        const noteType = validTypes.includes(action.type) ? action.type : "fact";
-                        const newId = supersedeNote(db, action.oldNoteId, {
-                            type: noteType,
-                            content: action.newContent,
-                            keywords: Array.isArray(action.keywords) ? action.keywords : [],
-                            confidence: Math.max(0, Math.min(1, action.confidence ?? 0.8)),
-                            priority: Math.max(0, Math.min(2, action.priority ?? 0)),
-                            sourceEpisodes: episodeIds,
-                        });
-                        supersededCount++;
-                        details.push(`[supersede] ${action.oldNoteId} → ${newId}: ${action.reason}`);
-                    }
-                    catch (err) {
-                        details.push(`[supersede-error] ${action.oldNoteId}: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-                if (supersededCount > 0) {
-                    log.info(`[memory] Contradiction resolution: superseded ${supersededCount} outdated note(s)`);
-                }
-                // Mark episodes as consolidated
-                markConsolidated(db, episodeIds);
-                // Log the consolidation
-                logConsolidation(db, {
-                    episodesProcessed: episodes.length,
-                    notesCreated: notesCreated + supersededCount,
-                    durationMs: Date.now() - startMs,
-                });
-            }
-            else {
-                for (const note of extractedNotes) {
-                    details.push(`[dry-run] [${note.type}] ${note.content}`);
-                    notesCreated++;
-                }
-                for (const action of supersedeActions) {
-                    details.push(`[dry-run] [supersede] ${action.oldNoteId} → ${action.reason}`);
-                }
-            }
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    catch (err) {
-        // Do NOT mark episodes as consolidated on failure — they should be
-        // retried on the next consolidation run.  Previously this was a silent
-        // data-loss bug: a transient OpenAI outage would permanently lose the
-        // episodes' knowledge without extracting anything.
-        const msg = err instanceof Error ? err.message : String(err);
-        log.error(`[memory] Intelligent consolidation failed (episodes NOT marked): ${msg}`);
-        details.push(`Consolidation failed (will retry): ${msg}`);
-    }
-    return {
-        episodesProcessed: episodes.length,
-        notesCreated,
-        durationMs: Date.now() - startMs,
-        details,
-    };
-}
-// ─── Forget ──────────────────────────────────────────────────────────────────
-export function forgetMemory(db, memoryId, reason) {
-    // Determine layer by prefix
-    if (memoryId.startsWith("ep_")) {
-        const existing = db.prepare(`SELECT episode_id FROM episodes WHERE episode_id = ?`).get(memoryId);
-        if (!existing)
-            return { layer: "episodic", deleted: false };
-        db.transaction(() => {
-            db.prepare(`DELETE FROM episodes WHERE episode_id = ?`).run(memoryId);
-            // Also delete associated voice signature
-            db.prepare(`DELETE FROM voice_signatures WHERE episode_id = ?`).run(memoryId);
-        })();
-        return { layer: "episodic", deleted: true };
-    }
-    if (memoryId.startsWith("sn_")) {
-        const existing = db.prepare(`SELECT note_id, keywords FROM semantic_notes WHERE note_id = ?`).get(memoryId);
-        if (!existing)
-            return { layer: "semantic", deleted: false };
-        const kws = parseJsonArray(existing.keywords);
-        db.transaction(() => {
-            db.prepare(`DELETE FROM semantic_notes WHERE note_id = ?`).run(memoryId);
-            db.prepare(`DELETE FROM note_embeddings WHERE note_id = ?`).run(memoryId);
-            decrementTopicIndexForKeywords(db, kws, "semantic");
-        })();
-        return { layer: "semantic", deleted: true };
-    }
-    if (memoryId.startsWith("pr_")) {
-        const existing = db.prepare(`SELECT procedure_id, name FROM procedures WHERE procedure_id = ?`).get(memoryId);
-        if (!existing)
-            return { layer: "procedural", deleted: false };
-        const kws = existing.name.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-        db.transaction(() => {
-            db.prepare(`DELETE FROM procedures WHERE procedure_id = ?`).run(memoryId);
-            decrementTopicIndexForKeywords(db, kws, "procedural");
-        })();
-        return { layer: "procedural", deleted: true };
-    }
-    // Unknown prefix — try all layers
-    let row = db.prepare(`SELECT episode_id FROM episodes WHERE episode_id = ?`).get(memoryId);
-    if (row) {
-        db.transaction(() => {
-            db.prepare(`DELETE FROM episodes WHERE episode_id = ?`).run(memoryId);
-            db.prepare(`DELETE FROM voice_signatures WHERE episode_id = ?`).run(memoryId);
-        })();
-        return { layer: "episodic", deleted: true };
-    }
-    row = db.prepare(`SELECT note_id, keywords FROM semantic_notes WHERE note_id = ?`).get(memoryId);
-    if (row) {
-        const kws = parseJsonArray(row.keywords);
-        db.transaction(() => {
-            db.prepare(`DELETE FROM semantic_notes WHERE note_id = ?`).run(memoryId);
-            db.prepare(`DELETE FROM note_embeddings WHERE note_id = ?`).run(memoryId);
-            decrementTopicIndexForKeywords(db, kws, "semantic");
-        })();
-        return { layer: "semantic", deleted: true };
-    }
-    row = db.prepare(`SELECT procedure_id, name FROM procedures WHERE procedure_id = ?`).get(memoryId);
-    if (row) {
-        const kws = (row.name).toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-        db.transaction(() => {
-            db.prepare(`DELETE FROM procedures WHERE procedure_id = ?`).run(memoryId);
-            decrementTopicIndexForKeywords(db, kws, "procedural");
-        })();
-        return { layer: "procedural", deleted: true };
-    }
-    return { layer: "unknown", deleted: false };
-}
-// ─── Embedding-based Semantic Search ─────────────────────────────────────────
-/** Store a pre-computed embedding vector for a semantic note. */
-export function saveNoteEmbedding(db, noteId, embedding) {
-    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-    db.prepare(`INSERT OR REPLACE INTO note_embeddings (note_id, embedding, model, created_at) VALUES (?, ?, ?, ?)`).run(noteId, buf, "text-embedding-3-small", nowISO());
-}
-/** Load all note embeddings into memory for cosine similarity search. */
-function loadAllEmbeddings(db, threadId) {
-    // When threadId is provided, return embeddings for notes in that thread OR global notes (thread_id IS NULL)
-    let sql = `SELECT ne.note_id, ne.embedding FROM note_embeddings ne
-       JOIN semantic_notes sn ON sn.note_id = ne.note_id
-       WHERE sn.valid_to IS NULL AND sn.superseded_by IS NULL`;
-    const params = [];
-    if (threadId !== undefined) {
-        sql += ` AND (sn.thread_id IS NULL OR sn.thread_id = ?)`;
-        params.push(threadId);
-    }
-    const rows = db.prepare(sql).all(...params);
-    const map = new Map();
-    for (const row of rows) {
-        map.set(row.note_id, new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4));
-    }
-    return map;
-}
-/**
- * Search semantic notes using embedding cosine similarity.
- * Returns notes sorted by similarity score, filtered by minimum threshold.
- */
-export function searchByEmbedding(db, queryEmbedding, options) {
-    const maxResults = options?.maxResults ?? 5;
-    const minSimilarity = options?.minSimilarity ?? 0.3;
-    // Load embeddings — filtered by thread when provided
-    const embeddings = loadAllEmbeddings(db, options?.threadId);
-    // Compute similarities
-    const scores = [];
-    for (const [noteId, emb] of embeddings) {
-        const sim = cosineSimilarity(queryEmbedding, emb);
-        if (sim >= minSimilarity) {
-            scores.push({ noteId, similarity: sim });
-        }
-    }
-    // Sort by similarity descending
-    scores.sort((a, b) => b.similarity - a.similarity);
-    const topIds = scores.slice(0, maxResults);
-    if (topIds.length === 0)
-        return [];
-    // Fetch full notes
-    const placeholders = topIds.map(() => "?").join(",");
-    const rows = db.prepare(`SELECT * FROM semantic_notes WHERE note_id IN (${placeholders})`).all(...topIds.map(s => s.noteId));
-    const noteMap = new Map();
-    for (const row of rows) {
-        const note = rowToSemanticNote(row);
-        noteMap.set(note.noteId, note);
-    }
-    // Update access counts
-    if (!options?.skipAccessTracking) {
-        const now = nowISO();
-        const updateStmt = db.prepare(`UPDATE semantic_notes SET access_count = access_count + 1, last_accessed = ? WHERE note_id = ?`);
-        db.transaction(() => {
-            for (const s of topIds)
-                updateStmt.run(now, s.noteId);
-        })();
-    }
-    // Return in similarity order
-    return topIds
-        .map(s => {
-        const note = noteMap.get(s.noteId);
-        return note ? { ...note, similarity: s.similarity } : null;
-    })
-        .filter((n) => n !== null);
-}
-/** Get note IDs that don't have embeddings yet (for backfill). */
-export function getNotesWithoutEmbeddings(db) {
-    return db.prepare(`SELECT sn.note_id as noteId, sn.content FROM semantic_notes sn
-         LEFT JOIN note_embeddings ne ON ne.note_id = sn.note_id
-         WHERE ne.note_id IS NULL AND sn.valid_to IS NULL AND sn.superseded_by IS NULL`).all();
-}
+export * from "./data/memory/index.js";
 //# sourceMappingURL=memory.js.map