sensorium-mcp 2.7.0 → 2.8.0

package/dist/memory.js

@@ -0,0 +1,680 @@
+import BetterSqlite3 from "better-sqlite3";
+import { randomUUID } from "crypto";
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync, statSync } from "fs";
+// ─── 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 = 1;
+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')),
+  modality       TEXT NOT NULL CHECK(modality IN ('text','voice','photo','video_note','document','mixed')),
+  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,
+  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 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 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,
+  notes_merged        INTEGER,
+  notes_superseded    INTEGER,
+  procedures_updated  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 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 schema version if not yet recorded
+    const existing = db.prepare("SELECT version FROM schema_version WHERE version = ?").get(SCHEMA_VERSION);
+    if (!existing) {
+        db.prepare("INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (?, ?)").run(SCHEMA_VERSION, nowISO());
+    }
+    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,
+        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);
+}
+export 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);
+}
+export 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, 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)), 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
+    const conditions = [];
+    const params = [];
+    for (const term of terms) {
+        conditions.push(`(LOWER(content) LIKE ? OR LOWER(keywords) LIKE ?)`);
+        params.push(`%${term}%`, `%${term}%`);
+    }
+    let sql = `SELECT * FROM semantic_notes WHERE valid_to IS NULL AND superseded_by IS NULL AND (${conditions.join(" OR ")})`;
+    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
+    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 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.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) {
+    const newId = saveSemanticNote(db, {
+        type: newNote.type,
+        content: newNote.content,
+        keywords: newNote.keywords,
+        confidence: newNote.confidence,
+        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);
+    return newId;
+}
+export function expireNote(db, noteId) {
+    const now = nowISO();
+    db.prepare(`UPDATE semantic_notes SET valid_to = ?, updated_at = ? WHERE note_id = ?`).run(now, now, noteId);
+}
+// ─── 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) {
+        conditions.push(`(LOWER(name) LIKE ? OR LOWER(description) LIKE ? OR LOWER(steps) LIKE ? OR LOWER(trigger_conditions) LIKE ?)`);
+        params.push(`%${term}%`, `%${term}%`, `%${term}%`, `%${term}%`);
+    }
+    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);
+}
+export function recordProcedureExecution(db, procedureId, success) {
+    const now = nowISO();
+    // Get current stats
+    const row = db.prepare(`SELECT times_executed, success_rate FROM procedures WHERE procedure_id = ?`).get(procedureId);
+    if (!row)
+        return;
+    const newCount = row.times_executed + 1;
+    // Weighted moving average for success rate
+    const newRate = (row.success_rate * row.times_executed + (success ? 1 : 0)) / newCount;
+    db.prepare(`UPDATE procedures SET times_executed = ?, success_rate = ?, last_executed_at = ?, updated_at = ? WHERE procedure_id = ?`).run(newCount, newRate, now, now, procedureId);
+}
+// ─── 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();
+}
+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);
+}
+export function logConsolidation(db, log) {
+    db.prepare(`INSERT INTO meta_consolidation_log
+       (run_at, episodes_processed, notes_created, notes_merged, notes_superseded, procedures_updated, duration_ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(nowISO(), log.episodesProcessed, log.notesCreated, log.notesMerged, log.notesSuperseded, log.proceduresUpdated, 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());
+}
+export 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);
+    const recentEpisodes = getRecentEpisodes(db, threadId, 5);
+    const topNotes = getTopSemanticNotes(db, { limit: 10, sortBy: "access_count" });
+    // Preferences first
+    const preferences = topNotes.filter((n) => n.type === "preference");
+    const otherNotes = topNotes.filter((n) => n.type !== "preference");
+    const sortedNotes = [...preferences, ...otherNotes].slice(0, 10);
+    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) {
+            lines.push(`- **[${note.type}]** ${note.content} (conf: ${note.confidence.toFixed(2)}, accessed: ${note.accessCount}x)`);
+        }
+        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");
+}
+// ─── 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.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 FROM semantic_notes WHERE note_id = ?`).get(memoryId);
+        if (!existing)
+            return { layer: "semantic", deleted: false };
+        db.prepare(`DELETE FROM semantic_notes WHERE note_id = ?`).run(memoryId);
+        return { layer: "semantic", deleted: true };
+    }
+    if (memoryId.startsWith("pr_")) {
+        const existing = db.prepare(`SELECT procedure_id FROM procedures WHERE procedure_id = ?`).get(memoryId);
+        if (!existing)
+            return { layer: "procedural", deleted: false };
+        db.prepare(`DELETE FROM procedures WHERE procedure_id = ?`).run(memoryId);
+        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.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 FROM semantic_notes WHERE note_id = ?`).get(memoryId);
+    if (row) {
+        db.prepare(`DELETE FROM semantic_notes WHERE note_id = ?`).run(memoryId);
+        return { layer: "semantic", deleted: true };
+    }
+    row = db.prepare(`SELECT procedure_id FROM procedures WHERE procedure_id = ?`).get(memoryId);
+    if (row) {
+        db.prepare(`DELETE FROM procedures WHERE procedure_id = ?`).run(memoryId);
+        return { layer: "procedural", deleted: true };
+    }
+    return { layer: "unknown", deleted: false };
+}
+//# sourceMappingURL=memory.js.map