sensorium-mcp 2.17.27 → 3.0.0

package/dist/data/memory/schema.js

@@ -6,815 +6,15 @@
  * `initMemoryDb()` to obtain the singleton handle.
  */
 import BetterSqlite3 from "better-sqlite3";
-import { mkdirSync, readFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { log } from "../../logger.js";
+import { SCHEMA_SQL, cleanupOldSentMessages } from "./schema-ddl.js";
+import { runMigrations } from "./migration-runner.js";
+import { ensureSchemaIntegrity } from "./schema-guard.js";
 import { nowISO } from "./utils.js";
-import { errorMessage } from "../../utils.js";
-// ─── Database Initialization ─────────────────────────────────────────────────
-const SCHEMA_VERSION = 20;
-// ─── 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.
- */
-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;
-    `);
-    },
-    6: (db) => {
-        // Per-thread reaction routing: track which message_id belongs to which thread_id
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS sent_messages (
-        message_id INTEGER PRIMARY KEY,
-        thread_id  INTEGER NOT NULL,
-        created_at TEXT DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_sent_messages_thread ON sent_messages(thread_id);
-    `);
-    },
-    7: (db) => {
-        // Topic registry table
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS topic_registry (
-        chat_id       TEXT NOT NULL,
-        name          TEXT NOT NULL COLLATE NOCASE,
-        thread_id     INTEGER NOT NULL,
-        registered_at TEXT NOT NULL DEFAULT (datetime('now')),
-        PRIMARY KEY (chat_id, name)
-      );
-    `);
-    },
-    8: (db) => {
-        // Add is_guardrail flag to semantic_notes for explicit guardrail tagging
-        try {
-            db.exec(`ALTER TABLE semantic_notes ADD COLUMN is_guardrail INTEGER NOT NULL DEFAULT 0`);
-        }
-        catch {
-            // Column already exists — safe to ignore
-        }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_sem_guardrail ON semantic_notes(is_guardrail) WHERE is_guardrail = 1 AND valid_to IS NULL`);
-    },
-    9: (db) => {
-        // Backfill orphan NULL thread_id notes: assign to the earliest (most-used) thread.
-        // These notes were created before thread_id tracking and have no source_episodes to infer from.
-        const oldest = db.prepare(`SELECT thread_id FROM semantic_notes WHERE thread_id IS NOT NULL GROUP BY thread_id ORDER BY MIN(created_at) ASC LIMIT 1`).get();
-        if (!oldest)
-            return;
-        const result = db.prepare(`UPDATE semantic_notes SET thread_id = ? WHERE thread_id IS NULL`).run(oldest.thread_id);
-        if (result.changes > 0) {
-            log.info(`[migration-9] Assigned ${result.changes} orphan notes to thread ${oldest.thread_id}`);
-        }
-    },
-    10: (db) => {
-        // Add "pinned" column: pinned notes always appear in bootstrap briefing.
-        try {
-            db.exec("ALTER TABLE semantic_notes ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0");
-        }
-        catch { /* already exists in fresh DBs */ }
-        db.exec("CREATE INDEX IF NOT EXISTS idx_sem_pinned ON semantic_notes(pinned) WHERE pinned = 1 AND valid_to IS NULL");
-        log.info("[migration-10] Added pinned column to semantic_notes");
-    },
-    11: (db) => {
-        // Temporal narratives: pre-generated summaries at day/week/month resolution
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS temporal_narratives (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id INTEGER NOT NULL,
-        resolution TEXT NOT NULL CHECK(resolution IN ('day', 'week', 'month', 'quarter', 'half_year')),
-        period_start TEXT NOT NULL,
-        period_end TEXT NOT NULL,
-        narrative TEXT NOT NULL,
-        source_episode_count INTEGER NOT NULL DEFAULT 0,
-        source_note_count INTEGER NOT NULL DEFAULT 0,
-        model TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(thread_id, resolution, period_start)
-      );
-      CREATE INDEX IF NOT EXISTS idx_narrative_thread_res ON temporal_narratives(thread_id, resolution, created_at DESC);
-    `);
-        log.info("[migration-11] Created temporal_narratives table");
-    },
-    12: (db) => {
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS thread_registry (
-        id              INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id       INTEGER NOT NULL UNIQUE,
-        name            TEXT NOT NULL,
-        type            TEXT NOT NULL CHECK(type IN ('root','daily','branch','worker')),
-        root_thread_id  INTEGER,
-        badge           TEXT NOT NULL DEFAULT 'root',
-        client          TEXT DEFAULT 'claude',
-        max_retries     INTEGER DEFAULT 5,
-        cooldown_ms     INTEGER DEFAULT 300000,
-        keep_alive      INTEGER DEFAULT 0,
-        created_at      TEXT NOT NULL,
-        last_active_at  TEXT,
-        status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','archived','expired'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_thread_reg_type ON thread_registry(type);
-      CREATE INDEX IF NOT EXISTS idx_thread_reg_root ON thread_registry(root_thread_id);
-      CREATE INDEX IF NOT EXISTS idx_thread_reg_status ON thread_registry(status);
-    `);
-        log.info("[migration-12] Created thread_registry table");
-    },
-    13: (db) => {
-        // session_reset_at may already exist if the DB was created with the latest SCHEMA_SQL
-        const cols = db.prepare("PRAGMA table_info(thread_registry)").all();
-        const hasCol = cols.some(c => c.name === "session_reset_at");
-        if (!hasCol) {
-            db.exec("ALTER TABLE thread_registry ADD COLUMN session_reset_at TEXT");
-        }
-        log.info("[migration-13] Added session_reset_at column to thread_registry");
-    },
-    14: (db) => {
-        // Widen temporal_narratives resolution CHECK to include 'quarter' and 'half_year'.
-        // SQLite doesn't support ALTER CONSTRAINT, so recreate the table.
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS temporal_narratives_new (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id INTEGER NOT NULL,
-        resolution TEXT NOT NULL CHECK(resolution IN ('day', 'week', 'month', 'quarter', 'half_year')),
-        period_start TEXT NOT NULL,
-        period_end TEXT NOT NULL,
-        narrative TEXT NOT NULL,
-        source_episode_count INTEGER NOT NULL DEFAULT 0,
-        source_note_count INTEGER NOT NULL DEFAULT 0,
-        model TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(thread_id, resolution, period_start)
-      );
-      INSERT OR IGNORE INTO temporal_narratives_new SELECT * FROM temporal_narratives;
-      DROP TABLE temporal_narratives;
-      ALTER TABLE temporal_narratives_new RENAME TO temporal_narratives;
-      CREATE INDEX IF NOT EXISTS idx_narrative_thread_res ON temporal_narratives(thread_id, resolution, created_at DESC);
-    `);
-        log.info("[migration-14] Widened temporal_narratives resolution CHECK to include quarter and half_year");
-    },
-    15: (db) => {
-        // Widen thread_registry status CHECK to include 'exited'.
-        // SQLite doesn't support ALTER CONSTRAINT, so recreate the table.
-        const existingColumns = db
-            .prepare("PRAGMA table_info(thread_registry)")
-            .all()
-            .map((r) => r.name);
-        rebuildThreadRegistryWithExitedStatus(db, existingColumns);
-        log.info("[migration-15] Widened thread_registry status CHECK to include 'exited'");
-    },
-    16: (db) => {
-        // Add daily_rotation column to thread_registry (default OFF).
-        // Decouples daily session rotation from keepAlive.
-        try {
-            db.exec(`ALTER TABLE thread_registry ADD COLUMN daily_rotation INTEGER NOT NULL DEFAULT 0`);
-        }
-        catch {
-            // Column may already exist from schema self-heal
-        }
-        log.info("[migration-16] Added daily_rotation column to thread_registry (default OFF)");
-    },
-    17: (db) => {
-        // Add autonomous_mode column to thread_registry (default OFF).
-        // Per-thread toggle for drive system autonomous mode.
-        try {
-            db.exec(`ALTER TABLE thread_registry ADD COLUMN autonomous_mode INTEGER NOT NULL DEFAULT 0`);
-        }
-        catch {
-            // Column may already exist from schema self-heal
-        }
-        log.info("[migration-17] Added autonomous_mode column to thread_registry (default OFF)");
-    },
-    18: (db) => {
-        // Backfill thread_registry from settings.json threadAgentTypes + keepAlive config.
-        // This ensures threads created before the registry existed are properly represented.
-        try {
-            const settingsPath = join(homedir(), ".remote-copilot-mcp", "settings.json");
-            let settings = {};
-            try {
-                settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-            }
-            catch { /* no settings */ }
-            const agentTypes = (settings.threadAgentTypes ?? {});
-            const keepAliveThreadId = settings.keepAliveThreadId;
-            const keepAliveClient = (settings.keepAliveClient ?? "claude");
-            const keepAliveEnabled = !!settings.keepAliveEnabled;
-            const upsert = db.prepare(`INSERT INTO thread_registry (thread_id, name, type, client, keep_alive, created_at, last_active_at, status)
-         VALUES (?, ?, 'root', ?, ?, ?, ?, 'active')
-         ON CONFLICT(thread_id) DO UPDATE SET
-           client = CASE WHEN excluded.client != 'claude' THEN excluded.client ELSE thread_registry.client END,
-           keep_alive = CASE WHEN excluded.keep_alive = 1 THEN 1 ELSE thread_registry.keep_alive END,
-           status = CASE WHEN thread_registry.status = 'archived' AND excluded.keep_alive = 1 THEN 'active' ELSE thread_registry.status END`);
-            let backfilled = 0;
-            const now = nowISO();
-            for (const [threadIdStr, client] of Object.entries(agentTypes)) {
-                const tid = Number(threadIdStr);
-                if (!Number.isFinite(tid))
-                    continue;
-                const isKeepAlive = keepAliveEnabled && keepAliveThreadId === tid ? 1 : 0;
-                const effectiveClient = isKeepAlive ? keepAliveClient : client;
-                upsert.run(tid, `Thread ${tid}`, effectiveClient, isKeepAlive, now, now);
-                backfilled++;
-            }
-            // Specifically fix thread 1327 if it exists and keepAlive is set for it
-            if (keepAliveEnabled && keepAliveThreadId) {
-                db.prepare(`UPDATE thread_registry SET keep_alive = 1, status = 'active', client = ? WHERE thread_id = ?`).run(keepAliveClient, keepAliveThreadId);
-            }
-            log.info(`[migration-18] Backfilled ${backfilled} threads from settings.json threadAgentTypes`);
-        }
-        catch (err) {
-            log.warn(`[migration-18] Backfill from settings.json failed: ${errorMessage(err)}`);
-        }
-    },
-    19: (db) => {
-        // Add telegram_topic_id column — allows logical thread_id to survive when
-        // a Telegram forum topic is deleted and recreated.
-        try {
-            db.exec(`ALTER TABLE thread_registry ADD COLUMN telegram_topic_id INTEGER`);
-        }
-        catch {
-            // Column may already exist from schema self-heal
-        }
-        log.info("[migration-19] Added telegram_topic_id column to thread_registry");
-    },
-    20: (db) => {
-        // Add identity_prompt column — per-thread first-person identity anchor
-        // injected at the TOP of the memory briefing to maintain personality continuity.
-        try {
-            db.exec(`ALTER TABLE thread_registry ADD COLUMN identity_prompt TEXT`);
-        }
-        catch {
-            // Column may already exist
-        }
-        log.info("[migration-20] Added identity_prompt column to thread_registry");
-    },
-    21: (db) => {
-        // Add working_directory column — persistent CWD for thread spawning.
-        // Ensures threads restart in the correct directory on resume/keep-alive.
-        try {
-            db.exec(`ALTER TABLE thread_registry ADD COLUMN working_directory TEXT`);
-        }
-        catch {
-            // Column may already exist
-        }
-        log.info("[migration-21] Added working_directory column to thread_registry");
-    },
-};
-/**
- * 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;
-    }
-}
-function rebuildThreadRegistryWithExitedStatus(db, existingColumns) {
-    const selectSessionResetAt = existingColumns.includes("session_reset_at")
-        ? "session_reset_at"
-        : "NULL";
-    const selectDailyRotation = existingColumns.includes("daily_rotation")
-        ? "daily_rotation"
-        : "0";
-    const selectAutonomousMode = existingColumns.includes("autonomous_mode")
-        ? "autonomous_mode"
-        : "0";
-    const selectTelegramTopicId = existingColumns.includes("telegram_topic_id")
-        ? "telegram_topic_id"
-        : "NULL";
-    const selectIdentityPrompt = existingColumns.includes("identity_prompt")
-        ? "identity_prompt"
-        : "NULL";
-    const selectWorkingDirectory = existingColumns.includes("working_directory")
-        ? "working_directory"
-        : "NULL";
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS thread_registry_new (
-      id                INTEGER PRIMARY KEY AUTOINCREMENT,
-      thread_id         INTEGER NOT NULL UNIQUE,
-      name              TEXT NOT NULL,
-      type              TEXT NOT NULL CHECK(type IN ('root','daily','branch','worker')),
-      root_thread_id    INTEGER,
-      badge             TEXT NOT NULL DEFAULT 'root',
-      client            TEXT DEFAULT 'claude',
-      max_retries       INTEGER DEFAULT 5,
-      cooldown_ms       INTEGER DEFAULT 300000,
-      keep_alive        INTEGER DEFAULT 0,
-      created_at        TEXT NOT NULL,
-      last_active_at    TEXT,
-      session_reset_at  TEXT,
-      status            TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','archived','expired','exited')),
-      daily_rotation    INTEGER NOT NULL DEFAULT 0,
-      autonomous_mode   INTEGER NOT NULL DEFAULT 0,
-      telegram_topic_id INTEGER,
-      identity_prompt   TEXT,
-      working_directory TEXT
-    );
-    INSERT OR IGNORE INTO thread_registry_new (
-      id, thread_id, name, type, root_thread_id, badge, client, max_retries,
-      cooldown_ms, keep_alive, created_at, last_active_at, session_reset_at,
-      status, daily_rotation, autonomous_mode, telegram_topic_id, identity_prompt, working_directory
-    )
-    SELECT
-      id, thread_id, name, type, root_thread_id, badge, client, max_retries,
-      cooldown_ms, keep_alive, created_at, last_active_at, ${selectSessionResetAt},
-      status, ${selectDailyRotation}, ${selectAutonomousMode}, ${selectTelegramTopicId}, ${selectIdentityPrompt}, ${selectWorkingDirectory}
-    FROM thread_registry;
-    DROP TABLE thread_registry;
-    ALTER TABLE thread_registry_new RENAME TO thread_registry;
-    CREATE INDEX IF NOT EXISTS idx_thread_reg_type ON thread_registry(type);
-    CREATE INDEX IF NOT EXISTS idx_thread_reg_root ON thread_registry(root_thread_id);
-    CREATE INDEX IF NOT EXISTS idx_thread_reg_status ON thread_registry(status);
-  `);
-}
-/**
- * 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: ${errorMessage(err)}. Will attempt self-heal.`);
-                // Don't throw — allow ensureSchemaIntegrity to fix what it can
-            }
-        }
-    }
-}
-/**
- * Self-healing: verify that critical columns exist after migrations.
- * If any are missing (e.g. a migration was skipped or failed), add them
- * idempotently so downstream queries never crash on a missing column.
- *
- * After each successful self-heal, we record the corresponding migration
- * version so the migration loop won't retry it on next startup.
- */
-function ensureSchemaIntegrity(db) {
-    const stampVersion = (v) => {
-        try {
-            db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(v, nowISO());
-        }
-        catch { /* non-critical */ }
-    };
-    const getTableSql = (tableName) => {
-        const row = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
-        return row?.sql ?? "";
-    };
-    const semanticNoteCols = db
-        .prepare("PRAGMA table_info(semantic_notes)")
-        .all()
-        .map((r) => r.name);
-    if (!semanticNoteCols.includes("is_guardrail")) {
-        log.info("[memory] Self-heal: adding missing is_guardrail column");
-        db.exec("ALTER TABLE semantic_notes ADD COLUMN is_guardrail INTEGER NOT NULL DEFAULT 0");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_sem_guardrail ON semantic_notes(is_guardrail) WHERE is_guardrail = 1 AND valid_to IS NULL");
-        stampVersion(8); // migration 8 added is_guardrail
-    }
-    if (!semanticNoteCols.includes("pinned")) {
-        log.info("[memory] Self-heal: adding missing pinned column");
-        db.exec("ALTER TABLE semantic_notes ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_sem_pinned ON semantic_notes(pinned) WHERE pinned = 1 AND valid_to IS NULL");
-        stampVersion(10); // migration 10 added pinned
-    }
-    if (!semanticNoteCols.includes("thread_id")) {
-        log.info("[memory] Self-heal: adding missing thread_id column to semantic_notes");
-        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");
-        stampVersion(4); // migration 4 added thread_id
-    }
-    if (!semanticNoteCols.includes("priority")) {
-        log.info("[memory] Self-heal: adding missing priority column to semantic_notes");
-        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");
-        stampVersion(3); // migration 3 added priority
-    }
-    // Also check episodes table for thread_id
-    const episodeCols = db
-        .prepare("PRAGMA table_info(episodes)")
-        .all()
-        .map((r) => r.name);
-    if (!episodeCols.includes("thread_id")) {
-        log.info("[memory] Self-heal: adding missing thread_id column to episodes");
-        db.exec("ALTER TABLE episodes ADD COLUMN thread_id INTEGER");
-        // Do not stamp a schema version here: no numbered migration owns this
-        // legacy repair, and stamping version 2 would incorrectly suppress the
-        // note_embeddings migration on the next startup.
-    }
-    // Self-heal: ensure temporal_narratives table exists (migration 11)
-    const hasTemporalNarratives = db
-        .prepare("SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name='temporal_narratives'")
-        .get();
-    if (hasTemporalNarratives.cnt === 0) {
-        log.info("[memory] Self-heal: creating missing temporal_narratives table");
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS temporal_narratives (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id INTEGER NOT NULL,
-        resolution TEXT NOT NULL CHECK(resolution IN ('day', 'week', 'month', 'quarter', 'half_year')),
-        period_start TEXT NOT NULL,
-        period_end TEXT NOT NULL,
-        narrative TEXT NOT NULL,
-        source_episode_count INTEGER NOT NULL DEFAULT 0,
-        source_note_count INTEGER NOT NULL DEFAULT 0,
-        model TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(thread_id, resolution, period_start)
-      );
-      CREATE INDEX IF NOT EXISTS idx_narrative_thread_res ON temporal_narratives(thread_id, resolution, created_at DESC);
-    `);
-        stampVersion(11);
-    }
-    else {
-        const temporalNarrativesSql = getTableSql("temporal_narratives");
-        const hasExpandedNarrativeResolution = temporalNarrativesSql.includes("'quarter'") &&
-            temporalNarrativesSql.includes("'half_year'");
-        if (!hasExpandedNarrativeResolution) {
-            log.info("[memory] Self-heal: widening temporal_narratives resolution CHECK");
-            db.exec(`
-        CREATE TABLE IF NOT EXISTS temporal_narratives_new (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          thread_id INTEGER NOT NULL,
-          resolution TEXT NOT NULL CHECK(resolution IN ('day', 'week', 'month', 'quarter', 'half_year')),
-          period_start TEXT NOT NULL,
-          period_end TEXT NOT NULL,
-          narrative TEXT NOT NULL,
-          source_episode_count INTEGER NOT NULL DEFAULT 0,
-          source_note_count INTEGER NOT NULL DEFAULT 0,
-          model TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          UNIQUE(thread_id, resolution, period_start)
-        );
-        INSERT OR IGNORE INTO temporal_narratives_new SELECT * FROM temporal_narratives;
-        DROP TABLE temporal_narratives;
-        ALTER TABLE temporal_narratives_new RENAME TO temporal_narratives;
-        CREATE INDEX IF NOT EXISTS idx_narrative_thread_res ON temporal_narratives(thread_id, resolution, created_at DESC);
-      `);
-            stampVersion(14);
-        }
-    }
-    const hasThreadRegistry = db
-        .prepare("SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name='thread_registry'")
-        .get();
-    if (hasThreadRegistry.cnt === 0) {
-        log.info("[memory] Self-heal: creating missing thread_registry table");
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS thread_registry (
-        id              INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id       INTEGER NOT NULL UNIQUE,
-        name            TEXT NOT NULL,
-        type            TEXT NOT NULL CHECK(type IN ('root','daily','branch','worker')),
-        root_thread_id  INTEGER,
-        badge           TEXT NOT NULL DEFAULT 'root',
-        client          TEXT DEFAULT 'claude',
-        max_retries     INTEGER DEFAULT 5,
-        cooldown_ms     INTEGER DEFAULT 300000,
-        keep_alive      INTEGER DEFAULT 0,
-        created_at      TEXT NOT NULL,
-        last_active_at  TEXT,
-        session_reset_at TEXT,
-        status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','archived','expired','exited')),
-        daily_rotation  INTEGER NOT NULL DEFAULT 0,
-        autonomous_mode INTEGER NOT NULL DEFAULT 0,
-        telegram_topic_id INTEGER,
-        identity_prompt TEXT,
-        working_directory TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_thread_reg_type ON thread_registry(type);
-      CREATE INDEX IF NOT EXISTS idx_thread_reg_root ON thread_registry(root_thread_id);
-      CREATE INDEX IF NOT EXISTS idx_thread_reg_status ON thread_registry(status);
-    `);
-        stampVersion(12);
-        stampVersion(13);
-        stampVersion(15);
-        stampVersion(16);
-        stampVersion(17);
-        stampVersion(19);
-        stampVersion(20);
-        stampVersion(21);
-    }
-    else {
-        const threadRegistryCols = db
-            .prepare("PRAGMA table_info(thread_registry)")
-            .all()
-            .map((r) => r.name);
-        if (!threadRegistryCols.includes("session_reset_at")) {
-            log.info("[memory] Self-heal: adding missing session_reset_at column to thread_registry");
-            db.exec("ALTER TABLE thread_registry ADD COLUMN session_reset_at TEXT");
-            stampVersion(13);
-        }
-        const threadRegistrySql = getTableSql("thread_registry");
-        if (!threadRegistrySql.includes("'exited'")) {
-            log.info("[memory] Self-heal: widening thread_registry status CHECK");
-            rebuildThreadRegistryWithExitedStatus(db, threadRegistryCols);
-            stampVersion(15);
-        }
-        if (!threadRegistryCols.includes("daily_rotation")) {
-            log.info("[memory] Self-heal: adding missing daily_rotation column to thread_registry");
-            db.exec("ALTER TABLE thread_registry ADD COLUMN daily_rotation INTEGER NOT NULL DEFAULT 0");
-            stampVersion(16);
-        }
-        if (!threadRegistryCols.includes("autonomous_mode")) {
-            log.info("[memory] Self-heal: adding missing autonomous_mode column to thread_registry");
-            db.exec("ALTER TABLE thread_registry ADD COLUMN autonomous_mode INTEGER NOT NULL DEFAULT 0");
-            stampVersion(17);
-        }
-        if (!threadRegistryCols.includes("telegram_topic_id")) {
-            log.info("[memory] Self-heal: adding missing telegram_topic_id column to thread_registry");
-            db.exec("ALTER TABLE thread_registry ADD COLUMN telegram_topic_id INTEGER");
-            stampVersion(19);
-        }
-        if (!threadRegistryCols.includes("identity_prompt")) {
-            log.info("[memory] Self-heal: adding missing identity_prompt column to thread_registry");
-            db.exec("ALTER TABLE thread_registry ADD COLUMN identity_prompt TEXT");
-            stampVersion(20);
-        }
-        if (!threadRegistryCols.includes("working_directory")) {
-            log.info("[memory] Self-heal: adding missing working_directory column to thread_registry");
-            db.exec("ALTER TABLE thread_registry ADD COLUMN working_directory TEXT");
-            stampVersion(21);
-        }
-    }
-}
-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,
-  is_guardrail    INTEGER NOT NULL DEFAULT 0,
-  pinned          INTEGER NOT NULL DEFAULT 0,
-  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 INDEX IF NOT EXISTS idx_sem_guardrail ON semantic_notes(is_guardrail) WHERE is_guardrail = 1 AND valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS idx_sem_pinned ON semantic_notes(pinned) WHERE pinned = 1 AND 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 sent_messages (
-  message_id INTEGER PRIMARY KEY,
-  thread_id  INTEGER NOT NULL,
-  created_at TEXT DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_sent_messages_thread ON sent_messages(thread_id);
-
-CREATE TABLE IF NOT EXISTS topic_registry (
-  chat_id       TEXT NOT NULL,
-  name          TEXT NOT NULL COLLATE NOCASE,
-  thread_id     INTEGER NOT NULL,
-  registered_at TEXT NOT NULL DEFAULT (datetime('now')),
-  PRIMARY KEY (chat_id, name)
-);
-
-CREATE TABLE IF NOT EXISTS temporal_narratives (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  thread_id INTEGER NOT NULL,
-  resolution TEXT NOT NULL CHECK(resolution IN ('day', 'week', 'month', 'quarter', 'half_year')),
-  period_start TEXT NOT NULL,
-  period_end TEXT NOT NULL,
-  narrative TEXT NOT NULL,
-  source_episode_count INTEGER NOT NULL DEFAULT 0,
-  source_note_count INTEGER NOT NULL DEFAULT 0,
-  model TEXT,
-  created_at TEXT NOT NULL DEFAULT (datetime('now')),
-  UNIQUE(thread_id, resolution, period_start)
-);
-CREATE INDEX IF NOT EXISTS idx_narrative_thread_res ON temporal_narratives(thread_id, resolution, created_at DESC);
-
-CREATE TABLE IF NOT EXISTS thread_registry (
-  id              INTEGER PRIMARY KEY AUTOINCREMENT,
-  thread_id       INTEGER NOT NULL UNIQUE,
-  name            TEXT NOT NULL,
-  type            TEXT NOT NULL CHECK(type IN ('root','daily','branch','worker')),
-  root_thread_id  INTEGER,
-  badge           TEXT NOT NULL DEFAULT 'root',
-  client          TEXT DEFAULT 'claude',
-  max_retries     INTEGER DEFAULT 5,
-  cooldown_ms     INTEGER DEFAULT 300000,
-  keep_alive      INTEGER DEFAULT 0,
-  created_at      TEXT NOT NULL,
-  last_active_at  TEXT,
-  session_reset_at TEXT,
-  status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','archived','expired','exited')),
-  daily_rotation  INTEGER NOT NULL DEFAULT 0,
-  autonomous_mode INTEGER NOT NULL DEFAULT 0,
-  telegram_topic_id INTEGER,
-  identity_prompt TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_thread_reg_type ON thread_registry(type);
-CREATE INDEX IF NOT EXISTS idx_thread_reg_root ON thread_registry(root_thread_id);
-CREATE INDEX IF NOT EXISTS idx_thread_reg_status ON thread_registry(status);
-
-CREATE TABLE IF NOT EXISTS schema_version (
-  version     INTEGER PRIMARY KEY,
-  applied_at  TEXT NOT NULL
-);
-`;
-/**
- * Backward-compatibility migration: if thread_registry is empty but we have
- * episodes for known threads, register them as root threads so existing
- * deployments don't lose visibility after the thread_registry feature lands.
- */
+export { cleanupOldSentMessages };
 function migrateExistingRootThreads(db) {
     const count = db.prepare("SELECT COUNT(*) as cnt FROM thread_registry").get().cnt;
     if (count > 0)
@@ -840,23 +40,14 @@ export function initMemoryDb() {
     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());
     }
-    // Run any pending migrations (will upgrade from stored version to SCHEMA_VERSION)
     runMigrations(db);
-    // Self-heal: ensure all critical columns exist even if a migration failed.
-    // After each successful column addition, record the corresponding migration
-    // version so it isn't retried but also isn't force-stamped over failures.
     ensureSchemaIntegrity(db);
-    // Auto-migrate existing threads as roots (backward compatibility)
     migrateExistingRootThreads(db);
-    // Backfill missing thread names from topic_registry
     try {
         db.prepare(`UPDATE thread_registry
        SET name = (
@@ -866,26 +57,7 @@ export function initMemoryDb() {
        )
        WHERE (thread_registry.name IS NULL OR thread_registry.name = '')`).run();
     }
-    catch { /* best-effort — topic_registry may not exist yet */ }
-    // NOTE: We deliberately do NOT force-stamp schema_version to SCHEMA_VERSION
-    // here. If a migration failed, its version is not recorded, so it will be
-    // retried on the next startup. This prevents permanently skipping failed
-    // migrations (which was the root cause of the "pinned column missing" bug).
+    catch { }
     return db;
 }
-/**
- * Delete sent_messages entries older than 7 days.
- * Safe to call periodically (e.g. during consolidation).
- */
-export function cleanupOldSentMessages(db) {
-    try {
-        const result = db.prepare(`DELETE FROM sent_messages WHERE created_at < datetime('now', '-7 days')`).run();
-        if (result.changes > 0) {
-            log.info(`[memory] Cleaned up ${result.changes} old sent_messages entries.`);
-        }
-    }
-    catch (err) {
-        log.warn(`[memory] sent_messages cleanup failed: ${errorMessage(err)}`);
-    }
-}
 //# sourceMappingURL=schema.js.map