vesper-memory 0.4.0 → 0.5.0

package/dist/server.js

@@ -16,11 +16,14 @@ import { CallToolRequestSchema, ListToolsRequestSchema, McpError, ErrorCode, } f
 import Redis from "ioredis";
 import { createRequire } from "module";
 import { randomUUID } from "crypto";
-import { validateInput, StoreMemoryInputSchema, RetrieveMemoryInputSchema, ListRecentInputSchema, GetStatsInputSchema, } from "./utils/validation.js";
+import { validateInput, StoreMemoryInputSchema, RetrieveMemoryInputSchema, ListRecentInputSchema, GetStatsInputSchema, RecordSkillOutcomeInputSchema, LoadSkillInputSchema, ShareContextInputSchema, StoreDecisionInputSchema, NamespaceStatsInputSchema, } from "./utils/validation.js";
 import { getSqlitePath, ensureDirectories } from "./utils/paths.js";
 import { createEmbeddingClient } from "./embeddings/client.js";
 import { HybridSearchEngine } from "./retrieval/hybrid-search.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 * as SmartRouter from "./router/smart-router.js";
 // Import better-sqlite3 constructor using createRequire
 const require = createRequire(import.meta.url);
@@ -34,6 +37,10 @@ let vesperEnabled = true;
 /**
  * Tool definitions for the MCP server
  */
+const NAMESPACE_PROP = {
+    type: "string",
+    description: "Namespace for multi-agent isolation (default: 'default')",
+};
 const TOOLS = [
     {
         name: "store_memory",
@@ -47,7 +54,7 @@ const TOOLS = [
                 },
                 memory_type: {
                     type: "string",
-                    enum: ["episodic", "semantic", "procedural"],
+                    enum: ["episodic", "semantic", "procedural", "decision"],
                     description: "Type of memory being stored",
                 },
                 metadata: {
@@ -55,6 +62,10 @@ const TOOLS = [
                     description: "Additional metadata (timestamp, source, tags, etc.)",
                     additionalProperties: true,
                 },
+                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')" },
+                task_id: { type: "string", description: "Task ID this memory is associated with" },
             },
             required: ["content", "memory_type"],
         },
@@ -72,7 +83,7 @@ const TOOLS = [
                 memory_types: {
                     type: "array",
                     items: { type: "string" },
-                    description: "Filter by memory types (episodic, semantic, procedural). Omit for all types.",
+                    description: "Filter by memory types (episodic, semantic, procedural, decision). Omit for all types.",
                 },
                 max_results: {
                     type: "number",
@@ -83,6 +94,10 @@ const TOOLS = [
                     enum: ["fast_path", "semantic", "full_text", "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" },
             },
             required: ["query"],
         },
@@ -101,6 +116,7 @@ const TOOLS = [
                     type: "string",
                     description: "Optional filter by memory type",
                 },
+                namespace: NAMESPACE_PROP,
             },
         },
     },
@@ -114,6 +130,7 @@ const TOOLS = [
                     type: "boolean",
                     description: "Include detailed per-layer statistics (default: false)",
                 },
+                namespace: NAMESPACE_PROP,
             },
         },
     },
@@ -141,6 +158,98 @@ const TOOLS = [
             properties: {},
         },
     },
+    {
+        name: "record_skill_outcome",
+        description: "Record success or failure feedback for a skill execution. Used to improve skill ranking over time.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                skill_id: {
+                    type: "string",
+                    description: "The ID of the skill to record feedback for",
+                },
+                outcome: {
+                    type: "string",
+                    enum: ["success", "failure"],
+                    description: "Whether the skill execution was successful or not",
+                },
+                satisfaction: {
+                    type: "number",
+                    description: "User satisfaction score (0-1). Required for success outcome.",
+                },
+                namespace: NAMESPACE_PROP,
+            },
+            required: ["skill_id", "outcome"],
+        },
+    },
+    {
+        name: "load_skill",
+        description: "Load full skill implementation on-demand. Use when a skill summary needs complete details for execution. Loaded skills are cached for the session.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                skill_id: {
+                    type: "string",
+                    description: "The ID of the skill to load",
+                },
+                namespace: NAMESPACE_PROP,
+            },
+            required: ["skill_id"],
+        },
+    },
+    {
+        name: "share_context",
+        description: "Share context (memories, skills, entities) from one namespace to another. Used for agent handoffs in multi-agent workflows.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source_namespace: { type: "string", description: "Namespace to share from" },
+                target_namespace: { type: "string", description: "Namespace to share to" },
+                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)" },
+            },
+            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.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                content: { type: "string", description: "The decision content" },
+                namespace: NAMESPACE_PROP,
+                agent_id: { type: "string", description: "ID of the agent making this decision" },
+                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 },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "list_namespaces",
+        description: "List all namespaces with memory counts. Useful for discovering active agent namespaces.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "namespace_stats",
+        description: "Get detailed statistics for a specific namespace including memory counts, entity counts, skill counts, and active agents.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                namespace: { type: "string", description: "The namespace to get stats for" },
+            },
+            required: ["namespace"],
+        },
+    },
 ];
 /**
  * Initialize connections to Redis, Qdrant, and SQLite
@@ -244,10 +353,71 @@ async function initializeConnections() {
             console.error("\x1b[32m💡 Solution:\x1b[0m Start Qdrant with: docker-compose up -d qdrant");
             connections.hybridSearch = undefined;
         }
-        // Initialize Smart Router with working memory
+        // Initialize Semantic Memory Layer (requires SQLite)
+        if (connections.sqlite) {
+            try {
+                // Initialize semantic memory schema
+                initializeSemanticMemorySchema();
+                connections.semanticMemory = new SemanticMemoryLayer(connections.sqlite);
+                console.error("[INFO] ✅ Semantic memory layer initialized");
+            }
+            catch (err) {
+                console.error("[WARN] Semantic memory initialization failed:", err instanceof Error ? err.message : String(err));
+            }
+        }
+        // Initialize Skill Library (requires SQLite)
+        if (connections.sqlite) {
+            try {
+                // Initialize skill library schema
+                initializeSkillLibrarySchema();
+                connections.skillLibrary = new SkillLibrary(connections.sqlite);
+                console.error("[INFO] ✅ Skill library initialized");
+            }
+            catch (err) {
+                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) {
+            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));
+                    }
+                });
+            }
+            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)");
+        }
+        // Initialize Smart Router with working memory and skill library
         SmartRouter.init({
             workingMemory: connections.workingMemory,
         });
+        // Initialize skill handler in router
+        if (connections.skillLibrary) {
+            SmartRouter.initSkillHandler(connections.skillLibrary);
+            console.error("[INFO] ✅ Smart router skill handler initialized");
+        }
+        // Initialize preference handler in router
+        if (connections.semanticMemory) {
+            SmartRouter.initPreferenceHandler(connections.semanticMemory);
+            console.error("[INFO] ✅ Smart router preference handler initialized");
+        }
         console.error("[INFO] ✅ Smart router initialized");
         // Print service status summary
         console.error("\n" + "=".repeat(60));
@@ -299,6 +469,280 @@ 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 */ }
+    }
+    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);
+  `);
+}
+/**
+ * Initialize SQLite schema for semantic memory (HippoRAG knowledge graph)
+ */
+function initializeSemanticMemorySchema() {
+    if (!connections.sqlite) {
+        throw new Error("SQLite not initialized");
+    }
+    connections.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS entities (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      description TEXT,
+      confidence REAL DEFAULT 1.0,
+      created_at TEXT NOT NULL,
+      last_accessed TEXT NOT NULL,
+      access_count INTEGER DEFAULT 1
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+
+    CREATE TABLE IF NOT EXISTS relationships (
+      id TEXT PRIMARY KEY,
+      source_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      relation_type TEXT NOT NULL,
+      strength REAL DEFAULT 0.8,
+      evidence TEXT,
+      created_at TEXT NOT NULL,
+      last_reinforced TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_id);
+
+    CREATE TABLE IF NOT EXISTS facts (
+      id TEXT PRIMARY KEY,
+      entity_id TEXT NOT NULL,
+      property TEXT NOT NULL,
+      value TEXT NOT NULL,
+      confidence REAL DEFAULT 1.0,
+      valid_from TEXT,
+      valid_until TEXT,
+      source_conversation TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_facts_entity ON facts(entity_id);
+
+    CREATE TABLE IF NOT EXISTS conflicts (
+      id TEXT PRIMARY KEY,
+      fact_id_1 TEXT,
+      fact_id_2 TEXT,
+      conflict_type TEXT,
+      description TEXT,
+      severity TEXT,
+      resolution_status TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS backup_metadata (
+      id TEXT PRIMARY KEY,
+      backup_type TEXT NOT NULL,
+      backup_path TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL
+    );
+  `);
+    // v0.5.0 namespace migration for semantic memory tables
+    const semanticNamespaceMigrations = [
+        "ALTER TABLE entities ADD COLUMN namespace TEXT DEFAULT 'default'",
+        "ALTER TABLE relationships ADD COLUMN namespace TEXT DEFAULT 'default'",
+        "ALTER TABLE facts ADD COLUMN namespace TEXT DEFAULT 'default'",
+        "ALTER TABLE conflicts ADD COLUMN namespace TEXT DEFAULT 'default'",
+    ];
+    for (const sql of semanticNamespaceMigrations) {
+        try {
+            connections.sqlite.exec(sql);
+        }
+        catch (_) { /* column already exists */ }
+    }
+    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);
+    CREATE INDEX IF NOT EXISTS idx_facts_namespace ON facts(namespace);
+    CREATE INDEX IF NOT EXISTS idx_conflicts_namespace ON conflicts(namespace);
+  `);
+}
+/**
+ * Initialize SQLite schema for skill library (procedural memory)
+ */
+function initializeSkillLibrarySchema() {
+    if (!connections.sqlite) {
+        throw new Error("SQLite not initialized");
+    }
+    connections.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS skills (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL,
+      category TEXT NOT NULL,
+      triggers TEXT NOT NULL,
+      success_count INTEGER DEFAULT 0,
+      failure_count INTEGER DEFAULT 0,
+      avg_user_satisfaction REAL DEFAULT 0.5
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_skills_category ON skills(category);
+  `);
+    // v0.5.0 namespace migration for skills table
+    try {
+        connections.sqlite.exec("ALTER TABLE skills ADD COLUMN namespace TEXT DEFAULT 'default'");
+    }
+    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 {
+        connections.sqlite.exec(`
+      -- Add lazy loading columns if they don't exist
+      -- SQLite 3.35.0+ supports IF NOT EXISTS for ALTER TABLE ADD COLUMN
+
+      -- Add summary column (lightweight description for context injection)
+      ALTER TABLE skills ADD COLUMN summary TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists, continue
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN is_archived INTEGER DEFAULT 0;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN last_used TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN created_at TEXT DEFAULT CURRENT_TIMESTAMP;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN last_modified TEXT DEFAULT CURRENT_TIMESTAMP;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN version INTEGER DEFAULT 1;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN code TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN code_type TEXT DEFAULT 'reference';
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN prerequisites TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN uses_skills TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN used_by_skills TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN created_from TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    try {
+        connections.sqlite.exec(`
+      ALTER TABLE skills ADD COLUMN notes TEXT;
+    `);
+    }
+    catch (err) {
+        // Column already exists
+    }
+    // Create indexes for lazy loading (idempotent)
+    connections.sqlite.exec(`
+    CREATE INDEX IF NOT EXISTS idx_skills_lazy_loading
+      ON skills(is_archived, avg_user_satisfaction DESC, success_count DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_skills_last_used
+      ON skills(last_used DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_skills_category_quality
+      ON skills(category, avg_user_satisfaction DESC, success_count DESC);
+  `);
+    // Update existing skills with defaults
+    connections.sqlite.exec(`
+    UPDATE skills
+    SET summary = CASE
+      WHEN summary IS NULL AND length(description) <= 100 THEN description
+      WHEN summary IS NULL THEN substr(description, 1, 97) || '...'
+      ELSE summary
+    END
+    WHERE summary IS NULL OR summary = '';
+
+    UPDATE skills
+    SET created_at = CURRENT_TIMESTAMP
+    WHERE created_at IS NULL;
+
+    UPDATE skills
+    SET last_modified = CURRENT_TIMESTAMP
+    WHERE last_modified IS NULL;
+
+    UPDATE skills
+    SET is_archived = 0
+    WHERE is_archived IS NULL;
+  `);
 }
 /**
  * Handle store_memory tool call
@@ -310,6 +754,7 @@ async function handleStoreMemory(input) {
     try {
         // Validate input
         const validatedInput = validateInput(StoreMemoryInputSchema, input);
+        const namespace = validatedInput.namespace || 'default';
         // Use pure UUID for Qdrant compatibility
         const id = randomUUID();
         const now = Date.now();
@@ -324,19 +769,22 @@ async function handleStoreMemory(input) {
                 console.error("[WARN] Failed to generate embedding (continuing without):", err instanceof Error ? err.message : String(err));
             }
         }
-        // Store in SQLite
+        // 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)
-      VALUES (?, ?, ?, ?, ?, ?)
+      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 || {}));
-        // Store embedding in Qdrant if available
+        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) {
             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}`);
@@ -346,10 +794,11 @@ async function handleStoreMemory(input) {
                 throw new McpError(ErrorCode.InternalError, `Qdrant storage failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        console.error(`[INFO] Memory stored: ${id} (type: ${validatedInput.memory_type}, length: ${validatedInput.content.length}, embedding: ${embedding ? "yes" : "no"})`);
+        console.error(`[INFO] Memory stored: ${id} (type: ${validatedInput.memory_type}, ns: ${namespace}, length: ${validatedInput.content.length}, embedding: ${embedding ? "yes" : "no"})`);
         return {
             success: true,
             memory_id: id,
+            namespace,
             timestamp: now,
             message: `Memory stored successfully (${validatedInput.memory_type})`,
             has_embedding: !!embedding,
@@ -369,18 +818,36 @@ async function handleRetrieveMemory(input) {
     try {
         // Validate input
         const validatedInput = validateInput(RetrieveMemoryInputSchema, input);
+        const namespace = validatedInput.namespace || 'default';
         const maxResults = validatedInput.max_results || 5;
+        // 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 } }]
+            } : {}),
+        };
         // Try semantic search if embedding service is available
         if (connections.embeddingClient && connections.hybridSearch) {
             try {
                 // Generate query embedding
                 const queryEmbedding = await connections.embeddingClient.embed(validatedInput.query);
-                // Perform hybrid search
-                const searchResults = await connections.hybridSearch.hybridSearch(queryEmbedding, maxResults);
-                console.error(`[INFO] Semantic search: query="${validatedInput.query}", results=${searchResults.length}`);
+                // 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);
+                }
+                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,
@@ -398,29 +865,45 @@ async function handleRetrieveMemory(input) {
                 console.error("[WARN] Semantic search failed, falling back to text search:", err instanceof Error ? err.message : String(err));
             }
         }
-        // Fallback: SQL-based text search
-        let query = "SELECT id, content, memory_type, created_at, metadata FROM memories";
-        const params = [];
+        // 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 += ` WHERE memory_type IN (${placeholders})`;
+            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}", results=${results.length}`);
+        console.error(`[INFO] Text search (fallback): query="${validatedInput.query}", ns=${namespace}, results=${results.length}`);
         return {
             success: true,
             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,
@@ -440,20 +923,22 @@ async function handleListRecent(input) {
     try {
         // Validate input
         const validatedInput = validateInput(ListRecentInputSchema, input);
+        const namespace = validatedInput.namespace || 'default';
         const limit = validatedInput.limit || 5;
-        let query = "SELECT id, content, memory_type, created_at FROM memories";
-        const params = [];
+        let query = "SELECT id, content, memory_type, created_at, agent_id, task_id FROM memories WHERE namespace = ?";
+        const params = [namespace];
         if (validatedInput.memory_type) {
-            query += " WHERE memory_type = ?";
+            query += " AND memory_type = ?";
             params.push(validatedInput.memory_type);
         }
         query += " ORDER BY created_at DESC LIMIT ?";
         params.push(limit);
         const stmt = connections.sqlite.prepare(query);
         const results = stmt.all(...params);
-        console.error(`[INFO] Listed ${results.length} recent memories (limit=${limit}, type=${validatedInput.memory_type || "all"})`);
+        console.error(`[INFO] Listed ${results.length} recent memories (ns=${namespace}, limit=${limit}, type=${validatedInput.memory_type || "all"})`);
         return {
             success: true,
+            namespace,
             limit,
             memory_type_filter: validatedInput.memory_type || null,
             entries: results.map((r) => ({
@@ -461,6 +946,8 @@ async function handleListRecent(input) {
                 content: r.content,
                 memory_type: r.memory_type,
                 created_at: r.created_at,
+                agent_id: r.agent_id,
+                task_id: r.task_id,
             })),
             count: results.length,
         };
@@ -479,15 +966,17 @@ async function handleGetStats(input) {
     try {
         // Validate input
         const validatedInput = validateInput(GetStatsInputSchema, input);
-        const countStmt = connections.sqlite.prepare("SELECT COUNT(*) as count FROM memories");
-        const countResult = countStmt.get();
+        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;
         const typeStmt = connections.sqlite.prepare(`
-      SELECT memory_type, COUNT(*) as count FROM memories GROUP BY memory_type
+      SELECT memory_type, COUNT(*) as count FROM memories WHERE namespace = ? GROUP BY memory_type
     `);
-        const typeResults = typeStmt.all();
+        const typeResults = typeStmt.all(namespace);
         const stats = {
             success: true,
+            namespace,
             timestamp: Date.now(),
             total_memories: totalMemories,
             redis_connected: connections.redis ? true : false,
@@ -556,6 +1045,342 @@ async function handleVesperStatus() {
             : "Vesper is in pass-through mode (memory operations are skipped)",
     };
 }
+/**
+ * Handle record_skill_outcome tool call
+ *
+ * Records success or failure feedback for a skill execution.
+ * Used to improve skill ranking over time.
+ */
+async function handleRecordSkillOutcome(input) {
+    if (!connections.skillLibrary) {
+        throw new McpError(ErrorCode.InternalError, "Skill library not available");
+    }
+    try {
+        // Validate input
+        const validatedInput = validateInput(RecordSkillOutcomeInputSchema, input);
+        if (validatedInput.outcome === "success") {
+            if (validatedInput.satisfaction === undefined) {
+                throw new McpError(ErrorCode.InvalidParams, "satisfaction is required for success outcome");
+            }
+            connections.skillLibrary.recordSuccess(validatedInput.skill_id, validatedInput.satisfaction);
+            console.error(`[INFO] Recorded skill success: ${validatedInput.skill_id} (satisfaction: ${validatedInput.satisfaction})`);
+        }
+        else {
+            connections.skillLibrary.recordFailure(validatedInput.skill_id);
+            console.error(`[INFO] Recorded skill failure: ${validatedInput.skill_id}`);
+        }
+        return {
+            success: true,
+            skill_id: validatedInput.skill_id,
+            outcome: validatedInput.outcome,
+            satisfaction: validatedInput.satisfaction,
+            message: `Skill ${validatedInput.outcome} recorded for ${validatedInput.skill_id}`,
+        };
+    }
+    catch (err) {
+        throw new McpError(ErrorCode.InternalError, `Failed to record skill outcome: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Handle load_skill tool call
+ *
+ * Loads full skill implementation on-demand when a skill is invoked.
+ * This is part of the lazy loading system to reduce token usage by 80-90%.
+ *
+ * Performance:
+ * - First load: ~20ms (database query)
+ * - Cached load: ~5ms (working memory cache hit)
+ *
+ * Caching:
+ * - Loaded skills are cached in Redis for 1 hour (3600s)
+ * - Cache automatically expires or can be invalidated
+ * - Reduces database load and improves response time
+ *
+ * @param input - LoadSkillInput with skill_id
+ * @returns Full skill implementation with all details
+ */
+async function handleLoadSkill(input) {
+    if (!connections.skillLibrary) {
+        throw new McpError(ErrorCode.InternalError, "Skill library not available");
+    }
+    try {
+        // Validate input
+        const validatedInput = validateInput(LoadSkillInputSchema, input);
+        const startTime = Date.now();
+        let fromCache = false;
+        // Step 1: Check cache first (if working memory available)
+        let fullSkill = null;
+        if (connections.workingMemory) {
+            try {
+                const cached = await connections.workingMemory.getCachedSkill(validatedInput.skill_id);
+                if (cached) {
+                    fullSkill = cached.skill;
+                    fromCache = true;
+                    console.error(`[INFO] Skill cache hit: ${fullSkill.name} (${validatedInput.skill_id}) ` +
+                        `access count: ${cached.access_count}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[WARN] Skill cache lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Step 2: Load from database if not cached
+        if (!fullSkill) {
+            fullSkill = connections.skillLibrary.loadFull(validatedInput.skill_id);
+            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
+                }
+                catch (err) {
+                    console.warn(`[WARN] Failed to cache skill: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        const loadTime = Date.now() - startTime;
+        console.error(`[INFO] Loaded full skill: ${fullSkill.name} (${validatedInput.skill_id}) ` +
+            `in ${loadTime}ms (${fromCache ? 'cache' : 'database'})`);
+        return {
+            success: true,
+            skill: {
+                id: fullSkill.id,
+                name: fullSkill.name,
+                summary: fullSkill.summary,
+                description: fullSkill.description,
+                category: fullSkill.category,
+                triggers: fullSkill.triggers,
+                code: fullSkill.code,
+                code_type: fullSkill.code_type,
+                prerequisites: fullSkill.prerequisites,
+                quality_score: fullSkill.quality_score,
+                success_count: fullSkill.success_count,
+                failure_count: fullSkill.failure_count,
+                avg_user_satisfaction: fullSkill.avg_user_satisfaction,
+                uses_skills: fullSkill.uses_skills,
+                used_by_skills: fullSkill.used_by_skills,
+                created_from: fullSkill.created_from,
+                created_at: fullSkill.created_at.toISOString(),
+                last_modified: fullSkill.last_modified.toISOString(),
+                last_used: fullSkill.last_used?.toISOString(),
+                version: fullSkill.version,
+                notes: fullSkill.notes,
+            },
+            load_time_ms: loadTime,
+            from_cache: fromCache,
+            message: `Loaded full skill: ${fullSkill.name}${fromCache ? ' (cached)' : ''}`,
+        };
+    }
+    catch (err) {
+        if (err instanceof McpError) {
+            throw err;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to load skill: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Handle share_context tool call
+ *
+ * Shares memories from one namespace to another for agent handoffs.
+ */
+async function handleShareContext(input) {
+    if (!connections.sqlite) {
+        throw new McpError(ErrorCode.InternalError, "SQLite database not available");
+    }
+    try {
+        const validatedInput = validateInput(ShareContextInputSchema, input);
+        const { source_namespace, target_namespace } = validatedInput;
+        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);
+        }
+        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 });
+        }
+        // Include entities if requested
+        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++;
+                }
+            }
+        }
+        // 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}`);
+        return {
+            success: true,
+            source_namespace,
+            target_namespace,
+            memories_shared: sharedItems.length,
+            entities_shared: entityCount,
+            handoff_id: handoffId,
+        };
+    }
+    catch (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.
+ */
+async function handleStoreDecision(input) {
+    if (!connections.sqlite) {
+        throw new McpError(ErrorCode.InternalError, "SQLite database not available");
+    }
+    try {
+        const validatedInput = validateInput(StoreDecisionInputSchema, input);
+        const namespace = validatedInput.namespace || 'default';
+        const id = randomUUID();
+        const now = Date.now();
+        // Build metadata with decay_factor
+        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,
+                    namespace,
+                    agent_id: validatedInput.agent_id,
+                    task_id: validatedInput.task_id,
+                    decay_factor: 0.25,
+                });
+                hasEmbedding = true;
+            }
+            catch (err) {
+                console.error("[WARN] Failed to generate embedding for decision:", err instanceof Error ? err.message : String(err));
+            }
+        }
+        // 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);
+            }
+        }
+        // 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'})`);
+        return {
+            success: true,
+            decision_id: id,
+            namespace,
+            timestamp: now,
+            has_embedding: hasEmbedding,
+            supersedes: validatedInput.supersedes || null,
+            existing_decisions_count: existingDecisions.length,
+            message: `Decision stored successfully`,
+        };
+    }
+    catch (err) {
+        throw new McpError(ErrorCode.InternalError, `Failed to store decision: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Handle list_namespaces tool call
+ */
+async function handleListNamespaces() {
+    if (!connections.sqlite) {
+        throw new McpError(ErrorCode.InternalError, "SQLite database not available");
+    }
+    try {
+        const namespaces = connections.sqlite.prepare(`
+      SELECT namespace, COUNT(*) as memory_count,
+        COUNT(DISTINCT agent_id) as agent_count,
+        MAX(created_at) as last_activity
+      FROM memories
+      WHERE namespace IS NOT NULL
+      GROUP BY namespace
+      ORDER BY last_activity DESC
+    `).all();
+        return {
+            success: true,
+            namespaces: namespaces.map(ns => ({
+                namespace: ns.namespace,
+                memory_count: ns.memory_count,
+                agent_count: ns.agent_count,
+                last_activity: ns.last_activity,
+            })),
+            count: namespaces.length,
+        };
+    }
+    catch (err) {
+        throw new McpError(ErrorCode.InternalError, `Failed to list namespaces: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Handle namespace_stats tool call
+ */
+async function handleNamespaceStats(input) {
+    if (!connections.sqlite) {
+        throw new McpError(ErrorCode.InternalError, "SQLite database not available");
+    }
+    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;
+        return {
+            success: true,
+            namespace,
+            memories: memoryCount,
+            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 })),
+            agent_count: agents.length,
+        };
+    }
+    catch (err) {
+        throw new McpError(ErrorCode.InternalError, `Failed to get namespace stats: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Process tool calls
  */
@@ -589,6 +1414,18 @@ async function processTool(name, input) {
             return await handleListRecent(input);
         case "get_stats":
             return await handleGetStats(input);
+        case "record_skill_outcome":
+            return await handleRecordSkillOutcome(input);
+        case "load_skill":
+            return await handleLoadSkill(input);
+        case "share_context":
+            return await handleShareContext(input);
+        case "store_decision":
+            return await handleStoreDecision(input);
+        case "list_namespaces":
+            return await handleListNamespaces();
+        case "namespace_stats":
+            return await handleNamespaceStats(input);
         default:
             throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
     }
@@ -603,7 +1440,7 @@ async function main() {
     // Create MCP server
     const server = new Server({
         name: "vesper",
-        version: "0.1.0",
+        version: "0.5.0",
     }, {
         capabilities: {
             tools: {},
@@ -657,8 +1494,22 @@ async function main() {
     console.error("[INFO] Starting stdio transport...");
     await server.connect(transport);
     console.error("[INFO] Vesper running on stdio transport");
-    console.error("[INFO] Available tools: store_memory, retrieve_memory, list_recent, get_stats, vesper_enable, vesper_disable, vesper_status");
+    console.error("[INFO] Available tools: store_memory, retrieve_memory, list_recent, get_stats, record_skill_outcome, load_skill, vesper_enable, vesper_disable, vesper_status");
+}
+// Cleanup handler for graceful shutdown
+function cleanup() {
+    console.error('[INFO] Shutting down Vesper...');
+    if (connections.redis) {
+        connections.redis.disconnect();
+    }
+    if (connections.sqlite) {
+        connections.sqlite.close();
+    }
+    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));