vesper-memory 0.5.4 → 0.6.0

package/dist/server.js

@@ -20,10 +20,14 @@ import { validateInput, StoreMemoryInputSchema, RetrieveMemoryInputSchema, ListR
 import { getSqlitePath, ensureDirectories } from "./utils/paths.js";
 import { createEmbeddingClient } from "./embeddings/client.js";
 import { HybridSearchEngine } from "./retrieval/hybrid-search.js";
+import { MemoryRetriever } from "./retrieval/memory-retriever.js";
+import { IndexOutboxProcessor, initializeIndexOutboxSchema } from "./retrieval/index-outbox.js";
 import { WorkingMemoryLayer } from "./memory-layers/working-memory.js";
 import { SemanticMemoryLayer } from "./memory-layers/semantic-memory.js";
 import { SkillLibrary } from "./memory-layers/skill-library.js";
 import { ConsolidationPipeline } from "./consolidation/pipeline.js";
+import { ConsolidationScheduler } from "./scheduler/consolidation-scheduler.js";
+import { PerformanceMonitor } from "./utils/monitoring.js";
 import * as SmartRouter from "./router/smart-router.js";
 // Import better-sqlite3 constructor using createRequire
 const require = createRequire(import.meta.url);
@@ -34,6 +38,7 @@ const connections = {};
  * Used for A/B benchmarking (enabled vs disabled comparison)
  */
 let vesperEnabled = true;
+const retrievalMonitor = new PerformanceMonitor();
 /**
  * Tool definitions for the MCP server
  */
@@ -64,8 +69,29 @@ const TOOLS = [
                 },
                 namespace: NAMESPACE_PROP,
                 agent_id: { type: "string", description: "ID of the agent storing this memory" },
-                agent_role: { type: "string", description: "Role of the agent (e.g., 'orchestrator', 'code-reviewer')" },
+                agent_role: {
+                    type: "string",
+                    description: "Role of the agent (e.g., 'orchestrator', 'code-reviewer')",
+                },
                 task_id: { type: "string", description: "Task ID this memory is associated with" },
+                importance: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 1,
+                    description: "Write-time salience from 0 to 1 (default: 0.5)",
+                },
+                valid_from: {
+                    oneOf: [{ type: "number" }, { type: "string", format: "date-time" }],
+                    description: "When this memory became valid (Unix milliseconds or ISO 8601)",
+                },
+                valid_until: {
+                    oneOf: [{ type: "number" }, { type: "string", format: "date-time" }],
+                    description: "When this memory stopped being valid (Unix milliseconds or ISO 8601)",
+                },
+                expired_at: {
+                    oneOf: [{ type: "number" }, { type: "string", format: "date-time" }],
+                    description: "Optional retention expiry; expired memories are excluded from retrieval",
+                },
             },
             required: ["content", "memory_type"],
         },
@@ -91,13 +117,29 @@ const TOOLS = [
                 },
                 routing_strategy: {
                     type: "string",
-                    enum: ["fast_path", "semantic", "full_text", "graph"],
+                    enum: ["fast_path", "semantic", "full_text", "hybrid", "graph"],
                     description: "Retrieval strategy to use (default: auto-select)",
                 },
                 namespace: NAMESPACE_PROP,
                 agent_id: { type: "string", description: "Filter by agent ID" },
                 task_id: { type: "string", description: "Filter by task ID" },
                 exclude_agent: { type: "string", description: "Exclude memories from this agent" },
+                include_superseded: {
+                    type: "boolean",
+                    description: "Include decisions replaced by newer decisions (default: false)",
+                },
+                include_archived: {
+                    type: "boolean",
+                    description: "Include archived memories (default: false)",
+                },
+                as_of: {
+                    oneOf: [{ type: "number" }, { type: "string", format: "date-time" }],
+                    description: "Return memories valid at this time (Unix milliseconds or ISO 8601)",
+                },
+                explain: {
+                    type: "boolean",
+                    description: "Include content-free retrieval stage status and candidate counts",
+                },
             },
             required: ["query"],
         },
@@ -223,15 +265,21 @@ const TOOLS = [
                 task_id: { type: "string", description: "Filter source memories by task ID" },
                 query: { type: "string", description: "Semantic query to select relevant memories" },
                 max_items: { type: "number", description: "Max items to share (default: 10)" },
-                include_skills: { type: "boolean", description: "Include matching skills (default: false)" },
-                include_entities: { type: "boolean", description: "Include related entities (default: true)" },
+                include_skills: {
+                    type: "boolean",
+                    description: "Include matching skills (default: false)",
+                },
+                include_entities: {
+                    type: "boolean",
+                    description: "Include related entities (default: true)",
+                },
             },
             required: ["source_namespace", "target_namespace"],
         },
     },
     {
         name: "store_decision",
-        description: "Store an architectural or design decision with reduced decay and automatic conflict detection against existing decisions.",
+        description: "Store a versioned architectural or design decision with reduced decay; optionally close a superseded decision without deleting its history.",
         inputSchema: {
             type: "object",
             properties: {
@@ -241,7 +289,19 @@ const TOOLS = [
                 agent_role: { type: "string", description: "Role of the agent" },
                 task_id: { type: "string", description: "Related task ID" },
                 supersedes: { type: "string", description: "ID of a previous decision this replaces" },
-                metadata: { type: "object", description: "Additional metadata", additionalProperties: true },
+                valid_from: {
+                    oneOf: [{ type: "number" }, { type: "string", format: "date-time" }],
+                    description: "When this decision became valid (Unix milliseconds or ISO 8601)",
+                },
+                valid_until: {
+                    oneOf: [{ type: "number" }, { type: "string", format: "date-time" }],
+                    description: "When this decision stopped being valid (Unix milliseconds or ISO 8601)",
+                },
+                metadata: {
+                    type: "object",
+                    description: "Additional metadata",
+                    additionalProperties: true,
+                },
             },
             required: ["content"],
         },
@@ -269,34 +329,49 @@ const TOOLS = [
 /**
  * Initialize connections to Redis, Qdrant, and SQLite
  */
-async function initializeConnections() {
+export async function initializeConnections() {
     try {
         console.error("[INFO] Initializing connections to external services...");
         // Initialize Redis (optional - used for caching)
+        let redisClient;
         try {
-            connections.redis = new Redis({
+            if (process.env.VESPER_DISABLE_OPTIONAL_SERVICES === "1") {
+                throw new Error("disabled by VESPER_DISABLE_OPTIONAL_SERVICES");
+            }
+            redisClient = new Redis({
                 host: process.env.REDIS_HOST || "localhost",
                 port: parseInt(process.env.REDIS_PORT || "6379"),
                 password: process.env.REDIS_PASSWORD,
-                retryStrategy: (times) => Math.min(times * 50, 2000),
+                retryStrategy: (times) => (times <= 3 ? Math.min(times * 50, 2000) : null),
                 maxRetriesPerRequest: 3,
                 connectTimeout: 5000,
             });
-            connections.redis.on("connect", () => {
+            redisClient.on("connect", () => {
                 console.error("[INFO] ✅ Redis connected");
             });
-            connections.redis.on("error", (err) => {
+            redisClient.on("error", (err) => {
                 console.error("[WARN] Redis connection error:", err.message);
             });
             // Test connection with timeout
-            const pingTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Connection timeout")), 5000));
-            await Promise.race([connections.redis.ping(), pingTimeout]);
+            let pingTimer;
+            const pingTimeout = new Promise((_, reject) => {
+                pingTimer = setTimeout(() => reject(new Error("Connection timeout")), 5000);
+            });
+            try {
+                await Promise.race([redisClient.ping(), pingTimeout]);
+            }
+            finally {
+                if (pingTimer)
+                    clearTimeout(pingTimer);
+            }
+            connections.redis = redisClient;
             console.error("[INFO] ✅ Redis ping successful");
             // Initialize Working Memory Layer
-            connections.workingMemory = new WorkingMemoryLayer(connections.redis, 5);
+            connections.workingMemory = new WorkingMemoryLayer(redisClient, 5);
             console.error("[INFO] ✅ Working memory layer initialized");
         }
         catch (err) {
+            redisClient?.disconnect();
             const errorMsg = err instanceof Error ? err.message : String(err);
             console.error("\x1b[33m⚠️  Redis not available:\x1b[0m", errorMsg);
             console.error("\x1b[34mℹ️  Impact:\x1b[0m Working memory disabled");
@@ -312,6 +387,8 @@ async function initializeConnections() {
             const dbPath = process.env.SQLITE_DB || getSqlitePath();
             connections.sqlite = new DatabaseConstructor(dbPath);
             connections.sqlite.pragma("journal_mode = WAL");
+            connections.sqlite.pragma("foreign_keys = ON");
+            connections.sqlite.pragma("busy_timeout = 5000");
             // Initialize schema
             initializeSqliteSchema();
             // Clear logging about storage location
@@ -328,6 +405,9 @@ async function initializeConnections() {
         }
         // Initialize Embedding Service (optional - graceful degradation)
         try {
+            if (process.env.VESPER_DISABLE_OPTIONAL_SERVICES === "1") {
+                throw new Error("disabled by VESPER_DISABLE_OPTIONAL_SERVICES");
+            }
             connections.embeddingClient = createEmbeddingClient({
                 serviceUrl: process.env.EMBEDDING_SERVICE_URL || "http://localhost:8000",
                 timeout: 10000,
@@ -335,10 +415,7 @@ async function initializeConnections() {
             });
             // Test connection with timeout
             const healthTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Health check timeout")), 10000));
-            const health = await Promise.race([
-                connections.embeddingClient.health(),
-                healthTimeout,
-            ]);
+            const health = await Promise.race([connections.embeddingClient.health(), healthTimeout]);
             console.error(`[INFO] ✅ Embedding service connected: ${health.model} (${health.dimensions}-dim)`);
         }
         catch (err) {
@@ -350,15 +427,15 @@ async function initializeConnections() {
         }
         // Initialize Hybrid Search Engine (optional - requires Qdrant)
         try {
+            if (process.env.VESPER_DISABLE_OPTIONAL_SERVICES === "1") {
+                throw new Error("disabled by VESPER_DISABLE_OPTIONAL_SERVICES");
+            }
             const qdrantUrl = process.env.QDRANT_URL || "http://localhost:6333";
             const qdrantApiKey = process.env.QDRANT_API_KEY;
             connections.hybridSearch = new HybridSearchEngine(qdrantUrl, "memory-vectors", 1024, qdrantApiKey);
             // Initialize collection with timeout
             const initTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Initialization timeout")), 10000));
-            await Promise.race([
-                connections.hybridSearch.initializeCollection(),
-                initTimeout,
-            ]);
+            await Promise.race([connections.hybridSearch.initializeCollection(), initTimeout]);
             console.error("[INFO] ✅ Qdrant hybrid search initialized");
         }
         catch (err) {
@@ -392,32 +469,72 @@ async function initializeConnections() {
                 console.error("[WARN] Skill library initialization failed:", err instanceof Error ? err.message : String(err));
             }
         }
-        // Initialize Consolidation Pipeline (requires all memory layers)
-        if (connections.workingMemory && connections.semanticMemory && connections.skillLibrary && connections.sqlite) {
+        // SQLite is canonical. FTS retrieval is always available; Redis and Qdrant
+        // are optional projections repaired through the durable index outbox.
+        if (connections.sqlite) {
+            connections.memoryRetriever = new MemoryRetriever({
+                db: connections.sqlite,
+                embeddingClient: connections.embeddingClient,
+                hybridSearch: connections.hybridSearch,
+            });
+            connections.memoryRetriever.initialize();
+            connections.indexOutbox = new IndexOutboxProcessor(connections.sqlite, {
+                embeddingClient: connections.embeddingClient,
+                hybridSearch: connections.hybridSearch,
+                workingMemory: connections.workingMemory,
+                projectionConfig: {
+                    qdrant: process.env.VESPER_DISABLE_OPTIONAL_SERVICES !== "1",
+                    redis: process.env.VESPER_DISABLE_OPTIONAL_SERVICES !== "1",
+                },
+            });
+            setImmediate(async () => {
+                try {
+                    const stats = await connections.indexOutbox.drain();
+                    console.error(`[INFO] Index outbox: ${stats.completed} completed, ${stats.pending} pending`);
+                }
+                catch (error) {
+                    console.error("[WARN] Index outbox drain failed:", error instanceof Error ? error.message : String(error));
+                }
+            });
+            connections.indexOutboxTimer = setInterval(async () => {
+                try {
+                    await connections.indexOutbox?.drain();
+                }
+                catch (error) {
+                    console.error("[WARN] Periodic index repair failed:", error instanceof Error ? error.message : String(error));
+                }
+            }, 30_000);
+            connections.indexOutboxTimer.unref();
+        }
+        // Consolidation reads canonical SQLite rows. Redis is an optional cache,
+        // not an ingestion dependency.
+        if (connections.semanticMemory && connections.skillLibrary && connections.sqlite) {
             try {
                 connections.consolidationPipeline = new ConsolidationPipeline(connections.workingMemory, connections.semanticMemory, connections.skillLibrary, connections.sqlite);
                 console.error("[INFO] ✅ Consolidation pipeline initialized");
-                // Run startup consolidation asynchronously (non-blocking)
-                // This runs every time the MCP server starts (when Claude Code restarts)
-                setImmediate(async () => {
-                    try {
-                        console.error("[INFO] 🔄 Running startup consolidation...");
-                        const stats = await connections.consolidationPipeline.consolidate();
-                        console.error(`[INFO] ✅ Startup consolidation complete: ${stats.memoriesProcessed} memories, ` +
-                            `${stats.entitiesExtracted} entities, ${stats.conflictsDetected} conflicts, ` +
-                            `${stats.skillsExtracted} skills in ${stats.duration}ms`);
-                    }
-                    catch (err) {
-                        console.error("[WARN] Startup consolidation failed:", err instanceof Error ? err.message : String(err));
-                    }
-                });
+                connections.consolidationScheduler = new ConsolidationScheduler(connections.consolidationPipeline);
+                connections.consolidationScheduler.start();
+                // Process the bounded, durable backlog without delaying MCP startup.
+                if (process.env.VESPER_DISABLE_STARTUP_CONSOLIDATION !== "1")
+                    setImmediate(async () => {
+                        try {
+                            console.error("[INFO] 🔄 Running startup consolidation...");
+                            const stats = await connections.consolidationScheduler.runNow();
+                            console.error(`[INFO] ✅ Startup consolidation complete: ${stats.memoriesProcessed} memories, ` +
+                                `${stats.entitiesExtracted} entities, ${stats.conflictsDetected} conflicts, ` +
+                                `${stats.skillsExtracted} skills in ${stats.duration}ms`);
+                        }
+                        catch (err) {
+                            console.error("[WARN] Startup consolidation failed:", err instanceof Error ? err.message : String(err));
+                        }
+                    });
             }
             catch (err) {
                 console.error("[WARN] Consolidation pipeline initialization failed:", err instanceof Error ? err.message : String(err));
             }
         }
         else {
-            console.error("[WARN] Consolidation pipeline not initialized (missing dependencies)");
+            console.error("[WARN] Consolidation pipeline not initialized (missing SQLite-backed layers)");
         }
         // Initialize Smart Router with all available dependencies
         SmartRouter.init({
@@ -442,10 +559,10 @@ async function initializeConnections() {
         console.error("\n" + "=".repeat(60));
         console.error("📊 Vesper Service Status:");
         console.error("=".repeat(60));
-        console.error(`SQLite:           ${connections.sqlite ? '\x1b[32m✓ Ready\x1b[0m' : '\x1b[31m✗ Failed\x1b[0m'} (required)`);
-        console.error(`Redis:            ${connections.redis ? '\x1b[32m✓ Ready\x1b[0m' : '\x1b[33m⚠ Disabled\x1b[0m'} (working memory)`);
-        console.error(`Embedding:        ${connections.embeddingClient ? '\x1b[32m✓ Ready\x1b[0m' : '\x1b[33m⚠ Disabled\x1b[0m'} (semantic search)`);
-        console.error(`Qdrant:           ${connections.hybridSearch ? '\x1b[32m✓ Ready\x1b[0m' : '\x1b[33m⚠ Disabled\x1b[0m'} (vector storage)`);
+        console.error(`SQLite:           ${connections.sqlite ? "\x1b[32m✓ Ready\x1b[0m" : "\x1b[31m✗ Failed\x1b[0m"} (required)`);
+        console.error(`Redis:            ${connections.redis ? "\x1b[32m✓ Ready\x1b[0m" : "\x1b[33m⚠ Disabled\x1b[0m"} (working memory)`);
+        console.error(`Embedding:        ${connections.embeddingClient ? "\x1b[32m✓ Ready\x1b[0m" : "\x1b[33m⚠ Disabled\x1b[0m"} (semantic search)`);
+        console.error(`Qdrant:           ${connections.hybridSearch ? "\x1b[32m✓ Ready\x1b[0m" : "\x1b[33m⚠ Disabled\x1b[0m"} (vector storage)`);
         console.error("=".repeat(60));
         // Show degraded mode warning if any optional services are down
         const optionalServicesDown = !connections.redis || !connections.embeddingClient || !connections.hybridSearch;
@@ -488,23 +605,66 @@ function initializeSqliteSchema() {
       updated_at INTEGER
     );
   `);
-    // v0.5.0 namespace migration for memories table
-    const memoryNamespaceCols = [
-        "ALTER TABLE memories ADD COLUMN namespace TEXT DEFAULT 'default'",
-        "ALTER TABLE memories ADD COLUMN agent_id TEXT",
-        "ALTER TABLE memories ADD COLUMN agent_role TEXT",
-        "ALTER TABLE memories ADD COLUMN task_id TEXT",
-    ];
-    for (const sql of memoryNamespaceCols) {
-        try {
-            connections.sqlite.exec(sql);
-        }
-        catch (_) { /* column already exists */ }
+    ensureColumn("memories", "consolidated_at", "INTEGER");
+    ensureColumn("memories", "namespace", "TEXT DEFAULT 'default'");
+    ensureColumn("memories", "agent_id", "TEXT");
+    ensureColumn("memories", "agent_role", "TEXT");
+    ensureColumn("memories", "task_id", "TEXT");
+    ensureColumn("memories", "importance", "REAL DEFAULT 0.5");
+    ensureColumn("memories", "access_count", "INTEGER DEFAULT 0");
+    ensureColumn("memories", "last_accessed", "INTEGER");
+    const addedValidFrom = ensureColumn("memories", "valid_from", "INTEGER");
+    ensureColumn("memories", "valid_until", "INTEGER");
+    ensureColumn("memories", "expired_at", "INTEGER");
+    ensureColumn("memories", "archived_at", "INTEGER");
+    // Leave legacy rows unconsolidated. The old write path did not reliably
+    // populate the Redis source consumed by the old pipeline, so bounded runs of
+    // the canonical SQLite pipeline must be allowed to backfill them.
+    if (addedValidFrom) {
+        connections.sqlite.exec("UPDATE memories SET valid_from = created_at WHERE valid_from IS NULL");
     }
     connections.sqlite.exec(`
     CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace);
     CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(namespace, agent_id);
+    CREATE INDEX IF NOT EXISTS idx_memories_task ON memories(namespace, task_id);
+    CREATE INDEX IF NOT EXISTS idx_memories_validity
+      ON memories(namespace, valid_from, valid_until, expired_at, archived_at);
   `);
+    initializeIndexOutboxSchema(connections.sqlite);
+    connections.sqlite.pragma("user_version = 1");
+}
+function ensureColumn(table, column, definition) {
+    if (!connections.sqlite)
+        throw new Error("SQLite not initialized");
+    const columns = connections.sqlite.pragma(`table_info(${table})`);
+    if (columns.some((existing) => existing.name === column))
+        return false;
+    connections.sqlite.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    return true;
+}
+function toEpochMillis(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "number")
+        return value;
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new McpError(ErrorCode.InvalidParams, `Invalid timestamp: ${value}`);
+    }
+    return parsed;
+}
+function sqliteEpochMillisExpression(expression) {
+    return `(CASE
+    WHEN typeof(${expression}) IN ('integer', 'real')
+      THEN CASE WHEN ABS(${expression}) < 100000000000 THEN ${expression} * 1000 ELSE ${expression} END
+    WHEN trim(${expression}) != '' AND trim(${expression}) NOT GLOB '*[^0-9.]*'
+      THEN CASE
+        WHEN ABS(CAST(${expression} AS REAL)) < 100000000000
+          THEN CAST(${expression} AS REAL) * 1000
+        ELSE CAST(${expression} AS REAL)
+      END
+    ELSE CAST(strftime('%s', ${expression}) AS INTEGER) * 1000
+  END)`;
 }
 /**
  * Initialize SQLite schema for semantic memory (HippoRAG knowledge graph)
@@ -560,6 +720,8 @@ function initializeSemanticMemorySchema() {
       fact_id_1 TEXT,
       fact_id_2 TEXT,
       conflict_type TEXT,
+      entity_id TEXT,
+      property TEXT,
       description TEXT,
       severity TEXT,
       resolution_status TEXT
@@ -567,10 +729,18 @@ function initializeSemanticMemorySchema() {
 
     CREATE TABLE IF NOT EXISTS backup_metadata (
       id TEXT PRIMARY KEY,
+      backup_timestamp TEXT,
       backup_type TEXT NOT NULL,
+      status TEXT DEFAULT 'completed',
       backup_path TEXT NOT NULL,
+      file_size_bytes INTEGER,
+      entities_count INTEGER,
+      relationships_count INTEGER,
+      facts_count INTEGER,
       created_at TEXT NOT NULL,
-      expires_at TEXT NOT NULL
+      expires_at TEXT NOT NULL,
+      notes TEXT,
+      metadata TEXT
     );
   `);
     // v0.5.0 namespace migration for semantic memory tables
@@ -584,8 +754,26 @@ function initializeSemanticMemorySchema() {
         try {
             connections.sqlite.exec(sql);
         }
-        catch (_) { /* column already exists */ }
+        catch (_) {
+            /* column already exists */
+        }
     }
+    ensureColumn("conflicts", "entity_id", "TEXT");
+    ensureColumn("conflicts", "property", "TEXT");
+    ensureColumn("backup_metadata", "backup_timestamp", "TEXT");
+    ensureColumn("backup_metadata", "status", "TEXT DEFAULT 'completed'");
+    ensureColumn("backup_metadata", "file_size_bytes", "INTEGER");
+    ensureColumn("backup_metadata", "entities_count", "INTEGER");
+    ensureColumn("backup_metadata", "relationships_count", "INTEGER");
+    ensureColumn("backup_metadata", "facts_count", "INTEGER");
+    ensureColumn("backup_metadata", "notes", "TEXT");
+    ensureColumn("backup_metadata", "metadata", "TEXT");
+    connections.sqlite.exec(`
+    UPDATE backup_metadata
+    SET backup_timestamp = COALESCE(backup_timestamp, created_at),
+        status = COALESCE(status, 'completed')
+  `);
+    ensureColumn("relationships", "last_decayed_at", "TEXT");
     connections.sqlite.exec(`
     CREATE INDEX IF NOT EXISTS idx_entities_namespace ON entities(namespace);
     CREATE INDEX IF NOT EXISTS idx_relationships_namespace ON relationships(namespace);
@@ -618,7 +806,9 @@ function initializeSkillLibrarySchema() {
     try {
         connections.sqlite.exec("ALTER TABLE skills ADD COLUMN namespace TEXT DEFAULT 'default'");
     }
-    catch (_) { /* column already exists */ }
+    catch (_) {
+        /* column already exists */
+    }
     connections.sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_skills_namespace ON skills(namespace);`);
     // Apply lazy loading migration (idempotent - safe to run multiple times)
     try {
@@ -771,56 +961,58 @@ async function handleStoreMemory(input) {
         throw new McpError(ErrorCode.InternalError, "SQLite database not available");
     }
     try {
-        // Validate input
         const validatedInput = validateInput(StoreMemoryInputSchema, input);
-        const namespace = validatedInput.namespace || 'default';
-        // Use pure UUID for Qdrant compatibility
+        const namespace = validatedInput.namespace || "default";
         const id = randomUUID();
         const now = Date.now();
-        // Generate embedding if service is available
-        let embedding;
-        if (connections.embeddingClient) {
-            try {
-                embedding = await connections.embeddingClient.embed(validatedInput.content);
-                console.error(`[INFO] Generated embedding for memory ${id}`);
-            }
-            catch (err) {
-                console.error("[WARN] Failed to generate embedding (continuing without):", err instanceof Error ? err.message : String(err));
-            }
+        const validFrom = toEpochMillis(validatedInput.valid_from) ?? now;
+        const validUntil = toEpochMillis(validatedInput.valid_until);
+        const expiredAt = toEpochMillis(validatedInput.expired_at);
+        if (validUntil !== undefined && validUntil <= validFrom) {
+            throw new McpError(ErrorCode.InvalidParams, "valid_until must be after valid_from");
         }
-        // Store in SQLite with namespace and agent attribution
-        const stmt = connections.sqlite.prepare(`
-      INSERT INTO memories (id, content, memory_type, created_at, updated_at, metadata, namespace, agent_id, agent_role, task_id)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(id, validatedInput.content, validatedInput.memory_type, now, now, JSON.stringify(validatedInput.metadata || {}), namespace, validatedInput.agent_id || null, validatedInput.agent_role || null, validatedInput.task_id || null);
-        // Store embedding in Qdrant if available (include namespace in payload)
-        if (embedding && connections.hybridSearch) {
+        const metadata = validatedInput.metadata || {};
+        const commit = connections.sqlite.transaction(() => {
+            connections.sqlite
+                .prepare(`
+        INSERT INTO memories (
+          id, content, memory_type, created_at, updated_at, metadata, namespace,
+          agent_id, agent_role, task_id, importance, access_count, last_accessed,
+          valid_from, valid_until, expired_at, archived_at, consolidated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, NULL, ?, ?, ?, NULL, NULL)
+      `)
+                .run(id, validatedInput.content, validatedInput.memory_type, now, now, JSON.stringify(metadata), namespace, validatedInput.agent_id || null, validatedInput.agent_role || null, validatedInput.task_id || null, validatedInput.importance ?? 0.5, validFrom, validUntil ?? null, expiredAt ?? null);
+            connections.indexOutbox?.enqueue({
+                memoryId: id,
+                operation: "upsert",
+                namespace,
+                content: validatedInput.content,
+                memoryType: validatedInput.memory_type,
+                metadata,
+                agentId: validatedInput.agent_id,
+                taskId: validatedInput.task_id,
+                createdAt: now,
+            });
+        });
+        commit();
+        if (connections.indexOutbox) {
             try {
-                await connections.hybridSearch.upsertMemory(id, embedding, {
-                    content: validatedInput.content,
-                    memory_type: validatedInput.memory_type,
-                    created_at: now,
-                    namespace,
-                    agent_id: validatedInput.agent_id,
-                    task_id: validatedInput.task_id,
-                    ...validatedInput.metadata,
-                });
-                console.error(`[INFO] Stored embedding in Qdrant for ${id}`);
+                await connections.indexOutbox.drain(20);
             }
-            catch (err) {
-                console.error("[ERROR] Failed to store embedding in Qdrant:", err instanceof Error ? err.message : String(err));
-                throw new McpError(ErrorCode.InternalError, `Qdrant storage failed: ${err instanceof Error ? err.message : String(err)}`);
+            catch (error) {
+                console.error("[WARN] Inline index drain failed; mutation remains durable:", error instanceof Error ? error.message : String(error));
             }
         }
-        console.error(`[INFO] Memory stored: ${id} (type: ${validatedInput.memory_type}, ns: ${namespace}, length: ${validatedInput.content.length}, embedding: ${embedding ? "yes" : "no"})`);
+        const indexState = connections.indexOutbox?.getState(id) ?? "pending";
+        console.error(`[INFO] Memory stored: ${id} (type: ${validatedInput.memory_type}, ns: ${namespace}, index: ${indexState})`);
         return {
             success: true,
             memory_id: id,
             namespace,
             timestamp: now,
             message: `Memory stored successfully (${validatedInput.memory_type})`,
-            has_embedding: !!embedding,
+            has_embedding: indexState === "indexed" && !!connections.hybridSearch,
+            index_state: indexState,
         };
     }
     catch (err) {
@@ -834,139 +1026,122 @@ async function handleRetrieveMemory(input) {
     if (!connections.sqlite) {
         throw new McpError(ErrorCode.InternalError, "SQLite database not available");
     }
+    const startedAt = performance.now();
     try {
-        // Validate input
         const validatedInput = validateInput(RetrieveMemoryInputSchema, input);
-        const namespace = validatedInput.namespace || 'default';
+        const namespace = validatedInput.namespace || "default";
         const maxResults = validatedInput.max_results || 5;
-        // Try SmartRouter first (unless a specific routing_strategy is requested)
-        if (!validatedInput.routing_strategy) {
-            try {
-                const routerContext = {
-                    userId: 'default',
-                    conversationId: 'mcp',
-                    timestamp: new Date(),
-                    namespace,
-                };
-                const routerResults = await SmartRouter.retrieve(validatedInput.query, routerContext);
-                if (routerResults.length > 0) {
-                    const classification = SmartRouter.classifyQuery(validatedInput.query);
-                    console.error(`[INFO] SmartRouter hit: query="${validatedInput.query}", type=${classification.type}, ns=${namespace}, results=${routerResults.length}`);
-                    return {
-                        success: true,
-                        query: validatedInput.query,
-                        namespace,
-                        routing_strategy: classification.type,
-                        results: routerResults.map((r) => ({
-                            id: r.id,
-                            content: r.content,
-                            memory_type: r.source,
-                            created_at: r.timestamp instanceof Date ? r.timestamp.getTime() : r.timestamp,
-                            similarity_score: r.similarity,
-                            confidence: r.confidence,
-                        })),
-                        count: routerResults.length,
-                    };
-                }
-                // Router returned empty - fall through to direct search
-                console.error(`[INFO] SmartRouter returned empty, falling back to direct search for: "${validatedInput.query}"`);
-            }
-            catch (err) {
-                console.error("[WARN] SmartRouter failed, falling back to direct search:", err instanceof Error ? err.message : String(err));
-            }
-        }
-        // Build Qdrant filter for namespace
-        const qdrantFilter = {
-            must: [
-                { key: "namespace", match: { value: namespace } },
-                ...(validatedInput.agent_id ? [{ key: "agent_id", match: { value: validatedInput.agent_id } }] : []),
-                ...(validatedInput.task_id ? [{ key: "task_id", match: { value: validatedInput.task_id } }] : []),
-            ],
-            ...(validatedInput.exclude_agent ? {
-                must_not: [{ key: "agent_id", match: { value: validatedInput.exclude_agent } }]
-            } : {}),
+        const commonFilters = {
+            namespace,
+            memoryTypes: validatedInput.memory_types,
+            maxResults,
+            agentId: validatedInput.agent_id,
+            taskId: validatedInput.task_id,
+            excludeAgent: validatedInput.exclude_agent,
+            includeSuperseded: validatedInput.include_superseded,
+            includeArchived: validatedInput.include_archived,
+            asOf: toEpochMillis(validatedInput.as_of),
         };
-        // Try semantic search if embedding service is available
-        if (connections.embeddingClient && connections.hybridSearch) {
+        if (!connections.memoryRetriever) {
+            throw new McpError(ErrorCode.InternalError, "Memory retriever not available");
+        }
+        // Redis can nominate recent candidates, but SQLite still authorizes and
+        // hydrates every returned field. A cache miss falls through to FTS.
+        if (validatedInput.routing_strategy === "fast_path" && connections.workingMemory) {
             try {
-                // Generate query embedding
-                const queryEmbedding = await connections.embeddingClient.embed(validatedInput.query);
-                // Perform hybrid search with namespace filter
-                let searchResults = await connections.hybridSearch.hybridSearch(queryEmbedding, maxResults, qdrantFilter);
-                // Fallback: if namespace is "default" and filtered search returns empty,
-                // retry without filter (backward compat for pre-namespace vectors)
-                if (searchResults.length === 0 && namespace === 'default') {
-                    searchResults = await connections.hybridSearch.hybridSearch(queryEmbedding, maxResults);
+                const cached = await connections.workingMemory.search(validatedInput.query, Math.min(maxResults * 4, 100), namespace);
+                const scores = new Map(cached.map(({ memory, similarity }) => [memory.conversationId, similarity]));
+                const results = connections.memoryRetriever.retrieveByIds(cached.map(({ memory }) => memory.conversationId), { ...commonFilters, similarityScores: scores, source: "fast_path" });
+                if (results.length > 0) {
+                    retrievalMonitor.recordCacheHit();
+                    return formatRetrievalResponse(validatedInput.query, namespace, "fast_path", results, validatedInput.explain
+                        ? {
+                            requested_strategy: "fast_path",
+                            effective_strategy: "fast_path",
+                            stages: [{ stage: "cache", candidate_count: cached.length, status: "ok" }],
+                            returned_count: results.length,
+                        }
+                        : undefined);
                 }
-                console.error(`[INFO] Semantic search: query="${validatedInput.query}", ns=${namespace}, results=${searchResults.length}`);
-                return {
-                    success: true,
-                    query: validatedInput.query,
-                    namespace,
-                    routing_strategy: "semantic",
-                    results: searchResults.map((r) => ({
-                        id: r.id,
-                        content: r.payload?.content,
-                        memory_type: r.payload?.memory_type,
-                        created_at: r.payload?.created_at,
-                        similarity_score: r.fusedScore,
-                        rank: r.rank,
-                        metadata: r.payload,
-                    })),
-                    count: searchResults.length,
-                };
+                retrievalMonitor.recordCacheMiss();
             }
-            catch (err) {
-                console.error("[WARN] Semantic search failed, falling back to text search:", err instanceof Error ? err.message : String(err));
+            catch (error) {
+                retrievalMonitor.recordCacheMiss();
+                console.error("[WARN] Fast-path lookup failed; falling back to canonical retrieval:", error instanceof Error ? error.message : String(error));
             }
         }
-        // Fallback: SQL-based text search with namespace filter
-        let query = "SELECT id, content, memory_type, created_at, metadata, agent_id, task_id FROM memories WHERE namespace = ?";
-        const params = [namespace];
-        // Add type filter if specified
-        if (validatedInput.memory_types && validatedInput.memory_types.length > 0) {
-            const placeholders = validatedInput.memory_types.map(() => "?").join(",");
-            query += ` AND memory_type IN (${placeholders})`;
-            params.push(...validatedInput.memory_types);
-        }
-        // Add agent/task filters
-        if (validatedInput.agent_id) {
-            query += " AND agent_id = ?";
-            params.push(validatedInput.agent_id);
-        }
-        if (validatedInput.task_id) {
-            query += " AND task_id = ?";
-            params.push(validatedInput.task_id);
-        }
-        if (validatedInput.exclude_agent) {
-            query += " AND (agent_id IS NULL OR agent_id != ?)";
-            params.push(validatedInput.exclude_agent);
-        }
-        query += " ORDER BY created_at DESC LIMIT ?";
-        params.push(maxResults);
-        const stmt = connections.sqlite.prepare(query);
-        const results = stmt.all(...params);
-        console.error(`[INFO] Text search (fallback): query="${validatedInput.query}", ns=${namespace}, results=${results.length}`);
-        return {
-            success: true,
+        // The legacy graph route did not implement the advertised PPR algorithm
+        // and returned non-memory entities. Preserve the public option as a safe
+        // compatibility alias while keeping the memory contract truthful.
+        const requestedStrategy = validatedInput.routing_strategy;
+        const strategy = requestedStrategy === "semantic" ||
+            requestedStrategy === "full_text" ||
+            requestedStrategy === "hybrid"
+            ? requestedStrategy
+            : requestedStrategy === "fast_path"
+                ? "full_text"
+                : "auto";
+        const response = await connections.memoryRetriever.retrieve({
             query: validatedInput.query,
-            namespace,
-            routing_strategy: "text_fallback",
-            results: results.map((r) => ({
-                id: r.id,
-                content: r.content,
-                memory_type: r.memory_type,
-                created_at: r.created_at,
-                agent_id: r.agent_id,
-                task_id: r.task_id,
-                metadata: JSON.parse(r.metadata || "{}"),
-            })),
-            count: results.length,
-        };
+            ...commonFilters,
+            strategy,
+            explain: validatedInput.explain,
+        });
+        const trace = response.trace
+            ? {
+                requested_strategy: requestedStrategy ?? "auto",
+                effective_strategy: response.strategy,
+                compatibility_fallback: requestedStrategy === "graph" ? "hybrid_or_full_text" : undefined,
+                candidate_limit: response.trace.candidateLimit,
+                stages: response.trace.stages.map((stage) => ({
+                    stage: stage.stage,
+                    candidate_count: stage.candidateCount,
+                    status: stage.status,
+                    fallback: stage.fallback,
+                })),
+                returned_count: response.trace.returnedCount,
+            }
+            : undefined;
+        console.error(`[INFO] Canonical retrieval: query="${validatedInput.query}", ns=${namespace}, ` +
+            `strategy=${response.strategy}, results=${response.results.length}`);
+        return formatRetrievalResponse(validatedInput.query, namespace, response.strategy, response.results, trace);
     }
     catch (err) {
+        if (err instanceof McpError)
+            throw err;
         throw new McpError(ErrorCode.InternalError, `Failed to retrieve memory: ${err instanceof Error ? err.message : String(err)}`);
     }
+    finally {
+        retrievalMonitor.recordLatency(performance.now() - startedAt);
+    }
+}
+function formatRetrievalResponse(query, namespace, strategy, results, trace) {
+    return {
+        success: true,
+        query,
+        namespace,
+        routing_strategy: strategy,
+        results: results.map((result) => ({
+            id: result.id,
+            content: result.content,
+            memory_type: result.memoryType,
+            created_at: result.createdAt,
+            updated_at: result.updatedAt,
+            namespace: result.namespace,
+            agent_id: result.agentId,
+            agent_role: result.agentRole,
+            task_id: result.taskId,
+            similarity_score: result.similarityScore,
+            dense_score: result.denseScore,
+            lexical_score: result.lexicalScore,
+            fused_score: result.fusedScore,
+            rank: result.rank,
+            sources: result.sources,
+            metadata: result.metadata,
+        })),
+        count: results.length,
+        ...(trace ? { trace } : {}),
+    };
 }
 /**
  * Handle list_recent tool call
@@ -978,10 +1153,58 @@ async function handleListRecent(input) {
     try {
         // Validate input
         const validatedInput = validateInput(ListRecentInputSchema, input);
-        const namespace = validatedInput.namespace || 'default';
+        const namespace = validatedInput.namespace || "default";
         const limit = validatedInput.limit || 5;
-        let query = "SELECT id, content, memory_type, created_at, agent_id, task_id FROM memories WHERE namespace = ?";
-        const params = [namespace];
+        const now = Date.now();
+        let query = `SELECT id, content, memory_type, created_at, agent_id, task_id
+       FROM memories
+       WHERE namespace = ?
+         AND (valid_from IS NULL OR ${sqliteEpochMillisExpression("valid_from")} IS NULL OR ${sqliteEpochMillisExpression("valid_from")} <= ?)
+         AND (valid_until IS NULL OR ${sqliteEpochMillisExpression("valid_until")} IS NULL OR ${sqliteEpochMillisExpression("valid_until")} > ?)
+         AND (expired_at IS NULL OR ${sqliteEpochMillisExpression("expired_at")} IS NULL OR ${sqliteEpochMillisExpression("expired_at")} > ?)
+         AND (archived_at IS NULL OR ${sqliteEpochMillisExpression("archived_at")} IS NULL OR ${sqliteEpochMillisExpression("archived_at")} > ?)
+         AND (metadata IS NULL OR json_valid(metadata) = 0 OR (
+           COALESCE(json_extract(metadata, '$.is_valid'), 1) != 0
+           AND COALESCE(json_extract(metadata, '$.invalid'), 0) = 0
+           AND COALESCE(json_extract(metadata, '$.is_archived'), 0) = 0
+           AND COALESCE(json_extract(metadata, '$.archived'), 0) = 0
+           AND (
+             valid_from IS NOT NULL
+             OR
+             json_extract(metadata, '$.valid_from') IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.valid_from')")} IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.valid_from')")} <= ?
+           )
+           AND (
+             valid_until IS NOT NULL
+             OR
+             json_extract(metadata, '$.valid_until') IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.valid_until')")} IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.valid_until')")} > ?
+           )
+           AND (
+             expired_at IS NOT NULL
+             OR
+             json_extract(metadata, '$.expired_at') IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.expired_at')")} IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.expired_at')")} > ?
+           )
+           AND (
+             archived_at IS NOT NULL
+             OR
+             json_extract(metadata, '$.archived_at') IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.archived_at')")} IS NULL
+             OR ${sqliteEpochMillisExpression("json_extract(metadata, '$.archived_at')")} > ?
+           )
+           AND (
+             json_extract(metadata, '$.superseded_by') IS NULL
+             OR (
+               json_extract(metadata, '$.superseded_at') IS NOT NULL
+               AND ${sqliteEpochMillisExpression("json_extract(metadata, '$.superseded_at')")} > ?
+             )
+           )
+         ))`;
+        const params = [namespace, now, now, now, now, now, now, now, now, now];
         if (validatedInput.memory_type) {
             query += " AND memory_type = ?";
             params.push(validatedInput.memory_type);
@@ -1021,7 +1244,7 @@ async function handleGetStats(input) {
     try {
         // Validate input
         const validatedInput = validateInput(GetStatsInputSchema, input);
-        const namespace = validatedInput.namespace || 'default';
+        const namespace = validatedInput.namespace || "default";
         const countStmt = connections.sqlite.prepare("SELECT COUNT(*) as count FROM memories WHERE namespace = ?");
         const countResult = countStmt.get(namespace);
         const totalMemories = countResult.count;
@@ -1046,14 +1269,53 @@ async function handleGetStats(input) {
         }
         stats.memory_type_breakdown = memoryTypeBreakdown;
         if (validatedInput.detailed) {
-            // Add detailed statistics
-            stats.estimated_storage_bytes = totalMemories * 500; // Rough estimate
-            stats.retrieval_latency_ms = {
-                p50: 15,
-                p95: 45,
-                p99: 120,
+            const pageCount = connections.sqlite.pragma("page_count", { simple: true });
+            const pageSize = connections.sqlite.pragma("page_size", { simple: true });
+            const retrievalMetrics = retrievalMonitor.getMetrics();
+            const lifecycle = connections.sqlite
+                .prepare(`
+        SELECT
+          SUM(CASE WHEN valid_until IS NOT NULL THEN 1 ELSE 0 END) AS closed,
+          SUM(CASE WHEN archived_at IS NOT NULL THEN 1 ELSE 0 END) AS archived,
+          SUM(access_count) AS total_accesses
+        FROM memories WHERE namespace = ?
+      `)
+                .get(namespace);
+            stats.sqlite_storage_bytes = pageCount * pageSize;
+            stats.retrieval_latency_ms = retrievalMetrics.latency;
+            stats.retrieval_requests_observed = retrievalMetrics.totalRequests;
+            stats.cache_hit_rate =
+                retrievalMetrics.totalCacheRequests > 0 ? retrievalMetrics.cacheHitRate : null;
+            stats.cache_requests_observed = retrievalMetrics.totalCacheRequests;
+            stats.index_outbox_pending = connections.indexOutbox?.getPendingCount() ?? null;
+            stats.lifecycle = {
+                closed: lifecycle.closed ?? 0,
+                archived: lifecycle.archived ?? 0,
+                total_accesses: lifecycle.total_accesses ?? 0,
             };
-            stats.cache_hit_rate = connections.redis ? 0.72 : null;
+            stats.consolidation_scheduler = connections.consolidationScheduler?.getStatus() ?? null;
+            if (connections.workingMemory) {
+                try {
+                    stats.working_memory = await connections.workingMemory.getStats(namespace);
+                }
+                catch (error) {
+                    stats.working_memory = {
+                        available: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            if (connections.hybridSearch) {
+                try {
+                    stats.vector_index = await connections.hybridSearch.getCollectionStats();
+                }
+                catch (error) {
+                    stats.vector_index = {
+                        available: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
         }
         console.error(`[INFO] Stats retrieved: ${totalMemories} total memories`);
         return stats;
@@ -1071,45 +1333,49 @@ async function handleDeleteMemory(input) {
     }
     try {
         const validatedInput = validateInput(DeleteMemoryInputSchema, input);
-        const namespace = validatedInput.namespace || 'default';
+        const namespace = validatedInput.namespace || "default";
         // Verify memory exists in SQLite
-        const existing = connections.sqlite.prepare("SELECT id, content, memory_type, created_at FROM memories WHERE id = ? AND namespace = ?").get(validatedInput.memory_id, namespace);
+        const existing = connections.sqlite
+            .prepare(`SELECT id, content, memory_type, created_at, metadata, agent_id, task_id
+       FROM memories WHERE id = ? AND namespace = ?`)
+            .get(validatedInput.memory_id, namespace);
         if (!existing) {
             return {
                 success: false,
                 message: `Memory not found: ${validatedInput.memory_id} in namespace '${namespace}'`,
             };
         }
-        // Delete from SQLite memories table
-        connections.sqlite.prepare("DELETE FROM memories WHERE id = ? AND namespace = ?").run(validatedInput.memory_id, namespace);
-        // Delete from Qdrant (best-effort)
-        if (connections.hybridSearch) {
-            try {
-                await connections.hybridSearch.deleteMemory(validatedInput.memory_id);
-            }
-            catch (err) {
-                console.error("[WARN] Failed to delete from Qdrant (continuing):", err instanceof Error ? err.message : String(err));
-            }
-        }
-        // Delete from Redis (best-effort)
-        if (connections.redis) {
+        // Canonical deletion and its projection tombstone commit together. Derived
+        // stores can be offline; the outbox is retried on later starts/writes.
+        const commit = connections.sqlite.transaction(() => {
+            connections.sqlite
+                .prepare("DELETE FROM facts WHERE source_conversation = ? AND namespace = ?")
+                .run(validatedInput.memory_id, namespace);
+            connections.sqlite
+                .prepare("DELETE FROM memories WHERE id = ? AND namespace = ?")
+                .run(validatedInput.memory_id, namespace);
+            connections.indexOutbox?.enqueue({
+                memoryId: existing.id,
+                operation: "delete",
+                namespace,
+                content: existing.content,
+                memoryType: existing.memory_type,
+                metadata: safeJsonObject(existing.metadata),
+                agentId: existing.agent_id ?? undefined,
+                taskId: existing.task_id ?? undefined,
+                createdAt: existing.created_at,
+            });
+        });
+        commit();
+        if (connections.indexOutbox) {
             try {
-                // Delete the individual working memory key
-                await connections.redis.del(`${namespace}:working:${validatedInput.memory_id}`);
-                // Remove from the recent list
-                await connections.redis.lrem(`${namespace}:working:recent`, 0, validatedInput.memory_id);
+                await connections.indexOutbox.drain(20);
             }
-            catch (err) {
-                console.error("[WARN] Failed to delete from Redis (continuing):", err instanceof Error ? err.message : String(err));
+            catch (error) {
+                console.error("[WARN] Inline index deletion failed; tombstone remains durable:", error instanceof Error ? error.message : String(error));
             }
         }
-        // Clean up orphaned facts where source_conversation = memory_id
-        try {
-            connections.sqlite.prepare("DELETE FROM facts WHERE source_conversation = ? AND namespace = ?").run(validatedInput.memory_id, namespace);
-        }
-        catch (err) {
-            console.error("[WARN] Failed to clean up orphaned facts (continuing):", err instanceof Error ? err.message : String(err));
-        }
+        const indexState = connections.indexOutbox?.getState(existing.id) ?? "pending";
         console.error(`[INFO] Memory deleted: ${validatedInput.memory_id} (type: ${existing.memory_type}, ns: ${namespace})`);
         return {
             success: true,
@@ -1120,6 +1386,7 @@ async function handleDeleteMemory(input) {
                 created_at: existing.created_at,
             },
             namespace,
+            index_state: indexState,
             message: `Memory deleted successfully`,
         };
     }
@@ -1130,6 +1397,19 @@ async function handleDeleteMemory(input) {
         throw new McpError(ErrorCode.InternalError, `Failed to delete memory: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function safeJsonObject(value) {
+    if (!value)
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * Handle vesper_enable tool call
  */
@@ -1185,11 +1465,11 @@ async function handleRecordSkillOutcome(input) {
             if (validatedInput.satisfaction === undefined) {
                 throw new McpError(ErrorCode.InvalidParams, "satisfaction is required for success outcome");
             }
-            connections.skillLibrary.recordSuccess(validatedInput.skill_id, validatedInput.satisfaction);
+            connections.skillLibrary.recordSuccess(validatedInput.skill_id, validatedInput.satisfaction, validatedInput.namespace);
             console.error(`[INFO] Recorded skill success: ${validatedInput.skill_id} (satisfaction: ${validatedInput.satisfaction})`);
         }
         else {
-            connections.skillLibrary.recordFailure(validatedInput.skill_id);
+            connections.skillLibrary.recordFailure(validatedInput.skill_id, validatedInput.namespace);
             console.error(`[INFO] Recorded skill failure: ${validatedInput.skill_id}`);
         }
         return {
@@ -1235,7 +1515,7 @@ async function handleLoadSkill(input) {
         let fullSkill = null;
         if (connections.workingMemory) {
             try {
-                const cached = await connections.workingMemory.getCachedSkill(validatedInput.skill_id);
+                const cached = await connections.workingMemory.getCachedSkill(validatedInput.skill_id, validatedInput.namespace);
                 if (cached) {
                     fullSkill = cached.skill;
                     fromCache = true;
@@ -1249,14 +1529,14 @@ async function handleLoadSkill(input) {
         }
         // Step 2: Load from database if not cached
         if (!fullSkill) {
-            fullSkill = connections.skillLibrary.loadFull(validatedInput.skill_id);
+            fullSkill = connections.skillLibrary.loadFull(validatedInput.skill_id, validatedInput.namespace);
             if (!fullSkill) {
                 throw new McpError(ErrorCode.InvalidParams, `Skill not found: ${validatedInput.skill_id}`);
             }
             // Cache the loaded skill (if working memory available)
             if (connections.workingMemory) {
                 try {
-                    await connections.workingMemory.cacheSkill(fullSkill, 3600); // 1 hour TTL
+                    await connections.workingMemory.cacheSkill(fullSkill, 3600, validatedInput.namespace); // 1 hour TTL
                 }
                 catch (err) {
                     console.warn(`[WARN] Failed to cache skill: ${err instanceof Error ? err.message : String(err)}`);
@@ -1265,7 +1545,7 @@ async function handleLoadSkill(input) {
         }
         const loadTime = Date.now() - startTime;
         console.error(`[INFO] Loaded full skill: ${fullSkill.name} (${validatedInput.skill_id}) ` +
-            `in ${loadTime}ms (${fromCache ? 'cache' : 'database'})`);
+            `in ${loadTime}ms (${fromCache ? "cache" : "database"})`);
         return {
             success: true,
             skill: {
@@ -1293,7 +1573,7 @@ async function handleLoadSkill(input) {
             },
             load_time_ms: loadTime,
             from_cache: fromCache,
-            message: `Loaded full skill: ${fullSkill.name}${fromCache ? ' (cached)' : ''}`,
+            message: `Loaded full skill: ${fullSkill.name}${fromCache ? " (cached)" : ""}`,
         };
     }
     catch (err) {
@@ -1315,63 +1595,195 @@ async function handleShareContext(input) {
     try {
         const validatedInput = validateInput(ShareContextInputSchema, input);
         const { source_namespace, target_namespace } = validatedInput;
+        if (source_namespace === target_namespace) {
+            throw new McpError(ErrorCode.InvalidParams, "source_namespace and target_namespace must be different");
+        }
         const maxItems = validatedInput.max_items || 10;
         const now = Date.now();
         const sharedItems = [];
-        // Query memories from source namespace
-        let memQuery = "SELECT id, content, memory_type, created_at, metadata, agent_id, task_id FROM memories WHERE namespace = ?";
-        const memParams = [source_namespace];
-        if (validatedInput.task_id) {
-            memQuery += " AND task_id = ?";
-            memParams.push(validatedInput.task_id);
+        let memoryIds;
+        if (validatedInput.query && connections.memoryRetriever) {
+            const selected = await connections.memoryRetriever.retrieve({
+                query: validatedInput.query,
+                namespace: source_namespace,
+                taskId: validatedInput.task_id,
+                maxResults: maxItems,
+                strategy: "auto",
+            });
+            memoryIds = selected.results.map((memory) => memory.id);
         }
-        memQuery += " ORDER BY created_at DESC LIMIT ?";
-        memParams.push(maxItems);
-        const memories = connections.sqlite.prepare(memQuery).all(...memParams);
-        // Copy memories to target namespace
-        for (const mem of memories) {
-            const newId = randomUUID();
-            connections.sqlite.prepare(`
-        INSERT INTO memories (id, content, memory_type, created_at, updated_at, metadata, namespace, agent_id, agent_role, task_id)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(newId, mem.content, mem.memory_type, mem.created_at, now, mem.metadata, target_namespace, mem.agent_id, null, mem.task_id);
-            sharedItems.push({ type: 'memory', id: newId, original_id: mem.id });
+        else {
+            let selectionSql = `
+        SELECT id FROM memories
+        WHERE namespace = ? AND archived_at IS NULL
+          AND (valid_from IS NULL OR valid_from <= ?)
+          AND (valid_until IS NULL OR valid_until > ?)
+          AND (expired_at IS NULL OR expired_at > ?)
+      `;
+            const selectionParams = [source_namespace, now, now, now];
+            if (validatedInput.task_id) {
+                selectionSql += " AND task_id = ?";
+                selectionParams.push(validatedInput.task_id);
+            }
+            selectionSql += " ORDER BY created_at DESC LIMIT ?";
+            selectionParams.push(maxItems);
+            memoryIds = connections.sqlite.prepare(selectionSql).all(...selectionParams).map((row) => row.id);
         }
-        // Include entities if requested
+        const memories = memoryIds.length > 0
+            ? connections.sqlite
+                .prepare(`
+          SELECT id, content, memory_type, created_at, metadata, agent_id,
+                 agent_role, task_id, importance, valid_from, valid_until, expired_at
+          FROM memories WHERE namespace = ? AND id IN (${memoryIds.map(() => "?").join(",")})
+        `)
+                .all(source_namespace, ...memoryIds)
+            : [];
+        const memoryOrder = new Map(memoryIds.map((id, index) => [id, index]));
+        memories.sort((a, b) => (memoryOrder.get(a.id) ?? 0) - (memoryOrder.get(b.id) ?? 0));
+        const selectedSkills = validatedInput.include_skills
+            ? connections.sqlite
+                .prepare(`
+          SELECT * FROM skills
+          WHERE namespace = ? AND is_archived = 0
+            AND (? IS NULL OR name LIKE ? OR description LIKE ? OR triggers LIKE ?)
+          ORDER BY avg_user_satisfaction DESC, success_count DESC
+          LIMIT ?
+        `)
+                .all(source_namespace, validatedInput.query ?? null, `%${validatedInput.query ?? ""}%`, `%${validatedInput.query ?? ""}%`, `%${validatedInput.query ?? ""}%`, maxItems)
+            : [];
+        const selectedEntities = validatedInput.include_entities
+            ? connections.sqlite
+                .prepare("SELECT * FROM entities WHERE namespace = ? LIMIT ?")
+                .all(source_namespace, maxItems)
+            : [];
+        let skillsShared = 0;
         let entityCount = 0;
-        if (validatedInput.include_entities) {
-            const entities = connections.sqlite.prepare("SELECT * FROM entities WHERE namespace = ? LIMIT ?").all(source_namespace, maxItems);
-            for (const entity of entities) {
-                if (connections.semanticMemory) {
-                    connections.semanticMemory.upsertEntity({ name: entity.name, type: entity.type, description: entity.description, confidence: entity.confidence }, target_namespace);
-                    entityCount++;
+        const handoffId = randomUUID();
+        const handoffContent = `Context handoff from namespace '${source_namespace}': ${memories.length} memories selected`;
+        const handoffMetadata = {
+            handoff: true,
+            source_namespace,
+            query: validatedInput.query ?? null,
+        };
+        const commit = connections.sqlite.transaction(() => {
+            for (const memory of memories) {
+                const newId = randomUUID();
+                const copiedMetadata = {
+                    ...safeJsonObject(memory.metadata),
+                    shared_from_namespace: source_namespace,
+                    shared_from_memory_id: memory.id,
+                    shared_at: now,
+                };
+                connections.sqlite
+                    .prepare(`
+          INSERT INTO memories (
+            id, content, memory_type, created_at, updated_at, metadata, namespace,
+            agent_id, agent_role, task_id, importance, access_count, last_accessed,
+            valid_from, valid_until, expired_at, archived_at, consolidated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, NULL, ?, ?, ?, NULL, NULL)
+        `)
+                    .run(newId, memory.content, memory.memory_type, memory.created_at, now, JSON.stringify(copiedMetadata), target_namespace, memory.agent_id, memory.agent_role, memory.task_id, memory.importance ?? 0.5, memory.valid_from ?? memory.created_at, memory.valid_until, memory.expired_at);
+                connections.indexOutbox?.enqueue({
+                    memoryId: newId,
+                    operation: "upsert",
+                    namespace: target_namespace,
+                    content: memory.content,
+                    memoryType: memory.memory_type,
+                    metadata: copiedMetadata,
+                    agentId: memory.agent_id ?? undefined,
+                    taskId: memory.task_id ?? undefined,
+                    createdAt: memory.created_at,
+                });
+                sharedItems.push({ type: "memory", id: newId, original_id: memory.id });
+            }
+            for (const skill of selectedSkills) {
+                const newId = randomUUID();
+                const targetName = `${skill.name} [${target_namespace}]`;
+                const result = connections.sqlite
+                    .prepare(`
+          INSERT OR IGNORE INTO skills (
+            id, name, description, summary, category, code, code_type, triggers,
+            prerequisites, success_count, failure_count, avg_user_satisfaction,
+            uses_skills, used_by_skills, namespace, is_archived, created_from,
+            created_at, last_used, last_modified, version, notes, metadata
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?)
+        `)
+                    .run(newId, targetName, skill.description, skill.summary, skill.category, skill.code, skill.code_type, skill.triggers, skill.prerequisites, skill.success_count, skill.failure_count, skill.avg_user_satisfaction, skill.uses_skills, skill.used_by_skills, target_namespace, skill.created_from, skill.created_at, skill.last_used, now, skill.version, skill.notes, skill.metadata);
+                if (result.changes > 0) {
+                    skillsShared++;
+                    sharedItems.push({ type: "skill", id: newId, original_id: skill.id });
+                }
+            }
+            for (const entity of selectedEntities) {
+                const existing = connections.sqlite
+                    .prepare("SELECT id FROM entities WHERE namespace = ? AND name = ? AND type = ? LIMIT 1")
+                    .get(target_namespace, entity.name, entity.type);
+                if (existing) {
+                    connections.sqlite
+                        .prepare(`UPDATE entities
+               SET description = COALESCE(?, description),
+                   confidence = MAX(confidence, ?), last_accessed = ?
+               WHERE id = ?`)
+                        .run(entity.description, entity.confidence ?? 1, new Date(now).toISOString(), existing.id);
+                }
+                else {
+                    connections.sqlite
+                        .prepare(`INSERT INTO entities (
+                 id, name, type, description, confidence, created_at,
+                 last_accessed, access_count, namespace
+               ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                        .run(randomUUID(), entity.name, entity.type, entity.description, entity.confidence ?? 1, entity.created_at ?? new Date(now).toISOString(), new Date(now).toISOString(), entity.access_count ?? 1, target_namespace);
                 }
+                entityCount++;
+            }
+            connections.sqlite
+                .prepare(`
+        INSERT INTO memories (
+          id, content, memory_type, created_at, updated_at, metadata, namespace,
+          importance, access_count, valid_from, consolidated_at
+        ) VALUES (?, ?, 'episodic', ?, ?, ?, ?, 0.5, 0, ?, NULL)
+      `)
+                .run(handoffId, handoffContent, now, now, JSON.stringify(handoffMetadata), target_namespace, now);
+            connections.indexOutbox?.enqueue({
+                memoryId: handoffId,
+                operation: "upsert",
+                namespace: target_namespace,
+                content: handoffContent,
+                memoryType: "episodic",
+                metadata: handoffMetadata,
+                createdAt: now,
+            });
+        });
+        commit();
+        if (connections.indexOutbox) {
+            try {
+                await connections.indexOutbox.drain(maxItems + 1);
+            }
+            catch (error) {
+                console.error("[WARN] Shared-context index drain failed; mutations remain durable:", error instanceof Error ? error.message : String(error));
             }
         }
-        // Store handoff event in target namespace
-        const handoffId = randomUUID();
-        connections.sqlite.prepare(`
-      INSERT INTO memories (id, content, memory_type, created_at, updated_at, metadata, namespace)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(handoffId, `Context handoff from namespace '${source_namespace}': ${memories.length} memories, ${entityCount} entities shared`, 'episodic', now, now, JSON.stringify({ handoff: true, source_namespace, items_shared: sharedItems.length, entities_shared: entityCount }), target_namespace);
-        console.error(`[INFO] Shared ${sharedItems.length} memories + ${entityCount} entities from ${source_namespace} to ${target_namespace}`);
+        console.error(`[INFO] Shared ${memories.length} memories + ${skillsShared} skills + ${entityCount} entities from ${source_namespace} to ${target_namespace}`);
         return {
             success: true,
             source_namespace,
             target_namespace,
-            memories_shared: sharedItems.length,
+            memories_shared: memories.length,
+            skills_shared: skillsShared,
             entities_shared: entityCount,
             handoff_id: handoffId,
         };
     }
     catch (err) {
+        if (err instanceof McpError)
+            throw err;
         throw new McpError(ErrorCode.InternalError, `Failed to share context: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /**
  * Handle store_decision tool call
  *
- * Stores a decision with reduced decay and conflict detection.
+ * Stores a versioned decision with reduced decay and explicit supersession.
  */
 async function handleStoreDecision(input) {
     if (!connections.sqlite) {
@@ -1379,64 +1791,130 @@ async function handleStoreDecision(input) {
     }
     try {
         const validatedInput = validateInput(StoreDecisionInputSchema, input);
-        const namespace = validatedInput.namespace || 'default';
+        const namespace = validatedInput.namespace || "default";
         const id = randomUUID();
         const now = Date.now();
-        // Build metadata with decay_factor
+        const validFrom = toEpochMillis(validatedInput.valid_from) ?? now;
+        const validUntil = toEpochMillis(validatedInput.valid_until);
+        if (validUntil !== undefined && validUntil <= validFrom) {
+            throw new McpError(ErrorCode.InvalidParams, "valid_until must be after valid_from");
+        }
         const metadata = {
             ...(validatedInput.metadata || {}),
             decay_factor: 0.25,
             supersedes: validatedInput.supersedes || null,
         };
-        // Store as decision memory type
-        connections.sqlite.prepare(`
-      INSERT INTO memories (id, content, memory_type, created_at, updated_at, metadata, namespace, agent_id, agent_role, task_id)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, validatedInput.content, 'decision', now, now, JSON.stringify(metadata), namespace, validatedInput.agent_id || null, validatedInput.agent_role || null, validatedInput.task_id || null);
-        // Generate embedding and store in Qdrant
-        let hasEmbedding = false;
-        if (connections.embeddingClient && connections.hybridSearch) {
-            try {
-                const embedding = await connections.embeddingClient.embed(validatedInput.content);
-                await connections.hybridSearch.upsertMemory(id, embedding, {
-                    content: validatedInput.content,
-                    memory_type: 'decision',
-                    created_at: now,
+        const superseded = validatedInput.supersedes
+            ? connections.sqlite
+                .prepare(`
+          SELECT id, content, memory_type, created_at, metadata, agent_id, task_id,
+                 valid_from, valid_until
+          FROM memories
+          WHERE id = ? AND namespace = ? AND memory_type = 'decision'
+        `)
+                .get(validatedInput.supersedes, namespace)
+            : undefined;
+        if (validatedInput.supersedes && !superseded) {
+            throw new McpError(ErrorCode.InvalidParams, `Superseded decision not found in namespace '${namespace}'`);
+        }
+        if (superseded) {
+            const supersededMetadata = safeJsonObject(superseded.metadata);
+            if (typeof supersededMetadata.superseded_by === "string") {
+                throw new McpError(ErrorCode.InvalidParams, "Decision has already been superseded");
+            }
+            if (superseded.valid_from !== null && validFrom < superseded.valid_from) {
+                throw new McpError(ErrorCode.InvalidParams, "A replacement decision cannot become effective before the decision it supersedes");
+            }
+            if (superseded.valid_until !== null && validFrom > superseded.valid_until) {
+                throw new McpError(ErrorCode.InvalidParams, "Replacement valid_from cannot be after the superseded decision's valid_until");
+            }
+        }
+        const commit = connections.sqlite.transaction(() => {
+            connections.sqlite
+                .prepare(`
+        INSERT INTO memories (
+          id, content, memory_type, created_at, updated_at, metadata, namespace,
+          agent_id, agent_role, task_id, importance, access_count, last_accessed,
+          valid_from, valid_until, expired_at, archived_at, consolidated_at
+        ) VALUES (?, ?, 'decision', ?, ?, ?, ?, ?, ?, ?, 0.9, 0, NULL, ?, ?, NULL, NULL, NULL)
+      `)
+                .run(id, validatedInput.content, now, now, JSON.stringify(metadata), namespace, validatedInput.agent_id || null, validatedInput.agent_role || null, validatedInput.task_id || null, validFrom, validUntil ?? null);
+            connections.indexOutbox?.enqueue({
+                memoryId: id,
+                operation: "upsert",
+                namespace,
+                content: validatedInput.content,
+                memoryType: "decision",
+                metadata,
+                agentId: validatedInput.agent_id,
+                taskId: validatedInput.task_id,
+                createdAt: now,
+            });
+            if (superseded) {
+                const oldMetadata = {
+                    ...safeJsonObject(superseded.metadata),
+                    superseded_by: id,
+                    superseded_at: validFrom,
+                    superseded_recorded_at: now,
+                };
+                const supersessionUpdate = connections.sqlite
+                    .prepare(`
+          UPDATE memories
+          SET metadata = ?, updated_at = ?, valid_until = ?
+          WHERE id = ? AND namespace = ?
+            AND metadata IS ? AND valid_until IS ?
+        `)
+                    .run(JSON.stringify(oldMetadata), now, validFrom, superseded.id, namespace, superseded.metadata, superseded.valid_until);
+                if (supersessionUpdate.changes !== 1) {
+                    throw new McpError(ErrorCode.InvalidParams, "Superseded decision changed concurrently; retry with the current decision");
+                }
+                connections.indexOutbox?.enqueue({
+                    memoryId: superseded.id,
+                    operation: "upsert",
                     namespace,
-                    agent_id: validatedInput.agent_id,
-                    task_id: validatedInput.task_id,
-                    decay_factor: 0.25,
+                    content: superseded.content,
+                    memoryType: superseded.memory_type,
+                    metadata: oldMetadata,
+                    agentId: superseded.agent_id ?? undefined,
+                    taskId: superseded.task_id ?? undefined,
+                    createdAt: superseded.created_at,
                 });
-                hasEmbedding = true;
             }
-            catch (err) {
-                console.error("[WARN] Failed to generate embedding for decision:", err instanceof Error ? err.message : String(err));
+        });
+        commit();
+        if (connections.indexOutbox) {
+            try {
+                await connections.indexOutbox.drain(20);
             }
-        }
-        // If supersedes, mark the old decision's metadata
-        if (validatedInput.supersedes) {
-            const oldMem = connections.sqlite.prepare("SELECT metadata FROM memories WHERE id = ? AND namespace = ?").get(validatedInput.supersedes, namespace);
-            if (oldMem) {
-                const oldMeta = JSON.parse(oldMem.metadata || '{}');
-                oldMeta.superseded_by = id;
-                connections.sqlite.prepare("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(oldMeta), now, validatedInput.supersedes);
+            catch (error) {
+                console.error("[WARN] Decision index drain failed; mutation remains durable:", error instanceof Error ? error.message : String(error));
             }
         }
-        // Check for conflicting decisions in same namespace
-        const existingDecisions = connections.sqlite.prepare("SELECT id, content FROM memories WHERE namespace = ? AND memory_type = 'decision' AND id != ? ORDER BY created_at DESC LIMIT 10").all(namespace, id);
-        console.error(`[INFO] Decision stored: ${id} (ns: ${namespace}, supersedes: ${validatedInput.supersedes || 'none'})`);
+        const indexState = connections.indexOutbox?.getState(id) ?? "pending";
+        // This is intentionally a count of candidates, not a claim that semantic
+        // conflicts were detected. Conflict classification requires a verifier.
+        const existingDecisions = connections.sqlite
+            .prepare(`SELECT id FROM memories
+       WHERE namespace = ? AND memory_type = 'decision' AND id != ?
+         AND valid_until IS NULL
+       ORDER BY created_at DESC LIMIT 10`)
+            .all(namespace, id);
+        console.error(`[INFO] Decision stored: ${id} (ns: ${namespace}, supersedes: ${validatedInput.supersedes || "none"})`);
         return {
             success: true,
             decision_id: id,
             namespace,
             timestamp: now,
-            has_embedding: hasEmbedding,
+            has_embedding: indexState === "indexed" && !!connections.hybridSearch,
+            index_state: indexState,
             supersedes: validatedInput.supersedes || null,
-            existing_decisions_count: existingDecisions.length,
+            potential_conflict_candidates: existingDecisions.length,
             message: `Decision stored successfully`,
         };
     }
     catch (err) {
+        if (err instanceof McpError)
+            throw err;
         throw new McpError(ErrorCode.InternalError, `Failed to store decision: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
@@ -1448,7 +1926,8 @@ async function handleListNamespaces() {
         throw new McpError(ErrorCode.InternalError, "SQLite database not available");
     }
     try {
-        const namespaces = connections.sqlite.prepare(`
+        const namespaces = connections.sqlite
+            .prepare(`
       SELECT namespace, COUNT(*) as memory_count,
         COUNT(DISTINCT agent_id) as agent_count,
         MAX(created_at) as last_activity
@@ -1456,10 +1935,11 @@ async function handleListNamespaces() {
       WHERE namespace IS NOT NULL
       GROUP BY namespace
       ORDER BY last_activity DESC
-    `).all();
+    `)
+            .all();
         return {
             success: true,
-            namespaces: namespaces.map(ns => ({
+            namespaces: namespaces.map((ns) => ({
                 namespace: ns.namespace,
                 memory_count: ns.memory_count,
                 agent_count: ns.agent_count,
@@ -1482,21 +1962,33 @@ async function handleNamespaceStats(input) {
     try {
         const validatedInput = validateInput(NamespaceStatsInputSchema, input);
         const namespace = validatedInput.namespace;
-        const memoryCount = connections.sqlite.prepare("SELECT COUNT(*) as count FROM memories WHERE namespace = ?").get(namespace).count;
-        const typeBreakdown = connections.sqlite.prepare("SELECT memory_type, COUNT(*) as count FROM memories WHERE namespace = ? GROUP BY memory_type").all(namespace);
-        const entityCount = connections.sqlite.prepare("SELECT COUNT(*) as count FROM entities WHERE namespace = ?").get(namespace).count;
-        const skillCount = connections.sqlite.prepare("SELECT COUNT(*) as count FROM skills WHERE namespace = ?").get(namespace).count;
-        const agents = connections.sqlite.prepare("SELECT DISTINCT agent_id, agent_role FROM memories WHERE namespace = ? AND agent_id IS NOT NULL").all(namespace);
-        const decisionCount = connections.sqlite.prepare("SELECT COUNT(*) as count FROM memories WHERE namespace = ? AND memory_type = 'decision'").get(namespace).count;
+        const memoryCount = connections.sqlite
+            .prepare("SELECT COUNT(*) as count FROM memories WHERE namespace = ?")
+            .get(namespace).count;
+        const typeBreakdown = connections.sqlite
+            .prepare("SELECT memory_type, COUNT(*) as count FROM memories WHERE namespace = ? GROUP BY memory_type")
+            .all(namespace);
+        const entityCount = connections.sqlite
+            .prepare("SELECT COUNT(*) as count FROM entities WHERE namespace = ?")
+            .get(namespace).count;
+        const skillCount = connections.sqlite
+            .prepare("SELECT COUNT(*) as count FROM skills WHERE namespace = ?")
+            .get(namespace).count;
+        const agents = connections.sqlite
+            .prepare("SELECT DISTINCT agent_id, agent_role FROM memories WHERE namespace = ? AND agent_id IS NOT NULL")
+            .all(namespace);
+        const decisionCount = connections.sqlite
+            .prepare("SELECT COUNT(*) as count FROM memories WHERE namespace = ? AND memory_type = 'decision'")
+            .get(namespace).count;
         return {
             success: true,
             namespace,
             memories: memoryCount,
-            memory_type_breakdown: Object.fromEntries(typeBreakdown.map(t => [t.memory_type, t.count])),
+            memory_type_breakdown: Object.fromEntries(typeBreakdown.map((t) => [t.memory_type, t.count])),
             entities: entityCount,
             skills: skillCount,
             decisions: decisionCount,
-            agents: agents.map(a => ({ agent_id: a.agent_id, agent_role: a.agent_role })),
+            agents: agents.map((a) => ({ agent_id: a.agent_id, agent_role: a.agent_role })),
             agent_count: agents.length,
         };
     }
@@ -1507,7 +1999,7 @@ async function handleNamespaceStats(input) {
 /**
  * Process tool calls
  */
-async function processTool(name, input) {
+export async function processTool(name, input) {
     console.error(`[INFO] Processing tool: ${name}`);
     // Handle toggle tools first (these always work regardless of enabled state)
     switch (name) {
@@ -1520,7 +2012,7 @@ async function processTool(name, input) {
     }
     // Check if Vesper is disabled (pass-through mode)
     if (!vesperEnabled) {
-        console.error('[INFO] Vesper is disabled (pass-through mode)');
+        console.error("[INFO] Vesper is disabled (pass-through mode)");
         return {
             success: true,
             disabled: true,
@@ -1565,7 +2057,7 @@ async function main() {
     // Create MCP server
     const server = new Server({
         name: "vesper",
-        version: "0.5.0",
+        version: "0.5.4",
     }, {
         capabilities: {
             tools: {},
@@ -1593,11 +2085,7 @@ async function main() {
             };
         }
         catch (err) {
-            const errorMessage = err instanceof McpError
-                ? err.message
-                : err instanceof Error
-                    ? err.message
-                    : String(err);
+            const errorMessage = err instanceof McpError ? err.message : err instanceof Error ? err.message : String(err);
             console.error(`[ERROR] Tool error for ${name}: ${errorMessage}`);
             return {
                 content: [
@@ -1623,21 +2111,37 @@ async function main() {
 }
 // Cleanup handler for graceful shutdown
 function cleanup() {
-    console.error('[INFO] Shutting down Vesper...');
+    console.error("[INFO] Shutting down Vesper...");
+    connections.consolidationScheduler?.stop();
+    if (connections.indexOutboxTimer)
+        clearInterval(connections.indexOutboxTimer);
     if (connections.redis) {
         connections.redis.disconnect();
     }
     if (connections.sqlite) {
         connections.sqlite.close();
     }
-    console.error('[INFO] Vesper shutdown complete');
+    console.error("[INFO] Vesper shutdown complete");
     process.exit(0);
 }
-process.on('SIGINT', cleanup);
-process.on('SIGTERM', cleanup);
-// Run the server
-main().catch((err) => {
-    console.error("[FATAL] Server error:", err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});
+export function closeConnectionsForTesting() {
+    connections.consolidationScheduler?.stop();
+    if (connections.indexOutboxTimer)
+        clearInterval(connections.indexOutboxTimer);
+    connections.redis?.disconnect();
+    if (connections.sqlite?.open)
+        connections.sqlite.close();
+    for (const key of Object.keys(connections)) {
+        delete connections[key];
+    }
+}
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+// Run the server unless a test imports the production handlers directly.
+if (process.env.VESPER_SKIP_AUTO_START !== "1") {
+    main().catch((err) => {
+        console.error("[FATAL] Server error:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=server.js.map