feat: Vestige v1.5.0 — Cognitive Engine, memory dreaming, graph exploration, predictive retrieval

28-module CognitiveEngine with full neuroscience pipeline on every tool call.
FSRS-6 now fully automatic: periodic consolidation (6h timer + inline every
100 tool calls), real retrievability formula, episodic-to-semantic auto-merge,
cross-memory reinforcement, Park et al. triple retrieval scoring, ACT-R
base-level activation, personalized w20 optimization.

New tools (19 → 23):
- dream: memory consolidation via replay, discovers hidden connections
- explore_connections: graph traversal (chain, associations, bridges)
- predict: proactive retrieval based on context and activity patterns
- restore: memory restore from JSON backups

All existing tools upgraded with cognitive pre/post processing pipelines.
33 files changed, ~4,100 lines added.

crates/vestige-mcp/src/cognitive.rs

@@ -0,0 +1,103 @@
+//! CognitiveEngine — Stateful neuroscience modules that persist across tool calls.
+//!
+//! v1.5.0: Wires ALL unused vestige-core features into the MCP server.
+//! Each module is initialized once at startup and shared via Arc<Mutex<>>
+//! across all tool invocations.
+
+use vestige_core::{
+    // Neuroscience modules
+    ActivationNetwork, SynapticTaggingSystem, HippocampalIndex, ContextMatcher,
+    AccessibilityCalculator, CompetitionManager, StateUpdateService,
+    ImportanceSignals, NoveltySignal, ArousalSignal, RewardSignal, AttentionSignal,
+    // Advanced modules
+    ImportanceTracker, ReconsolidationManager, IntentDetector, ActivityTracker,
+    MemoryDreamer, MemoryChainBuilder, MemoryCompressor, CrossProjectLearner,
+    AdaptiveEmbedder, SpeculativeRetriever, ConsolidationScheduler,
+    // Search modules
+    Reranker, RerankerConfig,
+};
+use vestige_core::search::TemporalSearcher;
+use vestige_core::neuroscience::predictive_retrieval::PredictiveMemory;
+use vestige_core::neuroscience::prospective_memory::{ProspectiveMemory, IntentionParser};
+
+/// Stateful cognitive engine holding all neuroscience modules.
+///
+/// Lives on McpServer as `Arc<Mutex<CognitiveEngine>>` and is passed
+/// to tools that need persistent cross-call state (search, ingest,
+/// feedback, consolidation, new tools).
+pub struct CognitiveEngine {
+    // -- Neuroscience --
+    pub activation_network: ActivationNetwork,
+    pub synaptic_tagging: SynapticTaggingSystem,
+    pub hippocampal_index: HippocampalIndex,
+    pub context_matcher: ContextMatcher,
+    pub accessibility_calc: AccessibilityCalculator,
+    pub competition_mgr: CompetitionManager,
+    pub state_service: StateUpdateService,
+    pub importance_signals: ImportanceSignals,
+    pub novelty_signal: NoveltySignal,
+    pub arousal_signal: ArousalSignal,
+    pub reward_signal: RewardSignal,
+    pub attention_signal: AttentionSignal,
+    pub predictive_memory: PredictiveMemory,
+    pub prospective_memory: ProspectiveMemory,
+    pub intention_parser: IntentionParser,
+
+    // -- Advanced --
+    pub importance_tracker: ImportanceTracker,
+    pub reconsolidation: ReconsolidationManager,
+    pub intent_detector: IntentDetector,
+    pub activity_tracker: ActivityTracker,
+    pub dreamer: MemoryDreamer,
+    pub chain_builder: MemoryChainBuilder,
+    pub compressor: MemoryCompressor,
+    pub cross_project: CrossProjectLearner,
+    pub adaptive_embedder: AdaptiveEmbedder,
+    pub speculative_retriever: SpeculativeRetriever,
+    pub consolidation_scheduler: ConsolidationScheduler,
+
+    // -- Search --
+    pub reranker: Reranker,
+    pub temporal_searcher: TemporalSearcher,
+}
+
+impl CognitiveEngine {
+    /// Initialize all cognitive modules with default configurations.
+    pub fn new() -> Self {
+        Self {
+            // Neuroscience
+            activation_network: ActivationNetwork::new(),
+            synaptic_tagging: SynapticTaggingSystem::new(),
+            hippocampal_index: HippocampalIndex::new(),
+            context_matcher: ContextMatcher::new(),
+            accessibility_calc: AccessibilityCalculator::default(),
+            competition_mgr: CompetitionManager::new(),
+            state_service: StateUpdateService::new(),
+            importance_signals: ImportanceSignals::new(),
+            novelty_signal: NoveltySignal::new(),
+            arousal_signal: ArousalSignal::new(),
+            reward_signal: RewardSignal::new(),
+            attention_signal: AttentionSignal::new(),
+            predictive_memory: PredictiveMemory::new(),
+            prospective_memory: ProspectiveMemory::new(),
+            intention_parser: IntentionParser::new(),
+
+            // Advanced
+            importance_tracker: ImportanceTracker::new(),
+            reconsolidation: ReconsolidationManager::new(),
+            intent_detector: IntentDetector::new(),
+            activity_tracker: ActivityTracker::new(),
+            dreamer: MemoryDreamer::new(),
+            chain_builder: MemoryChainBuilder::new(),
+            compressor: MemoryCompressor::new(),
+            cross_project: CrossProjectLearner::new(),
+            adaptive_embedder: AdaptiveEmbedder::new(),
+            speculative_retriever: SpeculativeRetriever::new(),
+            consolidation_scheduler: ConsolidationScheduler::new(),
+
+            // Search
+            reranker: Reranker::new(RerankerConfig::default()),
+            temporal_searcher: TemporalSearcher::new(),
+        }
+    }
+}

crates/vestige-mcp/src/main.rs

@@ -27,6 +27,7 @@
 //! - Reconsolidation (memories editable on retrieval)
 //! - Memory Chains (reasoning paths)
 
+pub mod cognitive;
 mod protocol;
 mod resources;
 mod server;
@@ -156,54 +157,70 @@ async fn main() {
         }
     };
 
-    // Spawn background auto-consolidation so FSRS-6 decay scores stay fresh.
-    // Runs only if the last consolidation was more than 6 hours ago.
+    // Spawn periodic auto-consolidation so FSRS-6 decay scores stay fresh.
+    // Runs on startup (if needed) and then every N hours (default: 6).
+    // Configurable via VESTIGE_CONSOLIDATION_INTERVAL_HOURS env var.
     {
         let storage_clone = storage.clone();
         tokio::spawn(async move {
+            let interval_hours: u64 = std::env::var("VESTIGE_CONSOLIDATION_INTERVAL_HOURS")
+                .ok()
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(6);
+
             // Small delay so we don't block server startup / stdio handshake
             tokio::time::sleep(std::time::Duration::from_secs(2)).await;
 
-            let mut storage = storage_clone.lock().await;
+            loop {
+                // Check whether consolidation is actually needed
+                let should_run = {
+                    let storage = storage_clone.lock().await;
+                    match storage.get_last_consolidation() {
+                        Ok(Some(last)) => {
+                            let elapsed = chrono::Utc::now() - last;
+                            let stale = elapsed > chrono::Duration::hours(interval_hours as i64);
+                            if !stale {
+                                info!(
+                                    last_consolidation = %last,
+                                    "Skipping auto-consolidation (last run was < {} hours ago)",
+                                    interval_hours
+                                );
+                            }
+                            stale
+                        }
+                        Ok(None) => {
+                            info!("No previous consolidation found — running first auto-consolidation");
+                            true
+                        }
+                        Err(e) => {
+                            warn!("Could not read consolidation history: {} — running anyway", e);
+                            true
+                        }
+                    }
+                };
 
-            // Check whether consolidation is actually needed
-            let should_run = match storage.get_last_consolidation() {
-                Ok(Some(last)) => {
-                    let elapsed = chrono::Utc::now() - last;
-                    let stale = elapsed > chrono::Duration::hours(6);
-                    if !stale {
-                        info!(
-                            last_consolidation = %last,
-                            "Skipping auto-consolidation (last run was < 6 hours ago)"
-                        );
+                if should_run {
+                    let mut storage = storage_clone.lock().await;
+                    match storage.run_consolidation() {
+                        Ok(result) => {
+                            info!(
+                                nodes_processed = result.nodes_processed,
+                                decay_applied = result.decay_applied,
+                                embeddings_generated = result.embeddings_generated,
+                                duplicates_merged = result.duplicates_merged,
+                                activations_computed = result.activations_computed,
+                                duration_ms = result.duration_ms,
+                                "Periodic auto-consolidation complete"
+                            );
+                        }
+                        Err(e) => {
+                            warn!("Periodic auto-consolidation failed: {}", e);
+                        }
                     }
-                    stale
                 }
-                Ok(None) => {
-                    info!("No previous consolidation found — running first auto-consolidation");
-                    true
-                }
-                Err(e) => {
-                    warn!("Could not read consolidation history: {} — running anyway", e);
-                    true
-                }
-            };
 
-            if should_run {
-                match storage.run_consolidation() {
-                    Ok(result) => {
-                        info!(
-                            nodes_processed = result.nodes_processed,
-                            decay_applied = result.decay_applied,
-                            embeddings_generated = result.embeddings_generated,
-                            duration_ms = result.duration_ms,
-                            "Auto-consolidation complete"
-                        );
-                    }
-                    Err(e) => {
-                        warn!("Auto-consolidation failed: {}", e);
-                    }
-                }
+                // Sleep until next check
+                tokio::time::sleep(std::time::Duration::from_secs(interval_hours * 3600)).await;
             }
         });
     }
@@ -222,8 +239,12 @@ async fn main() {
         });
     }
 
+    // Create cognitive engine (stateful neuroscience modules)
+    let cognitive = Arc::new(Mutex::new(cognitive::CognitiveEngine::new()));
+    info!("CognitiveEngine initialized (26 modules)");
+
     // Create MCP server
-    let server = McpServer::new(storage);
+    let server = McpServer::new(storage, cognitive);
 
     // Create stdio transport
     let transport = StdioTransport::new();

crates/vestige-mcp/src/server.rs

@@ -4,10 +4,12 @@
 //! tool and resource handlers.
 
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tracing::{debug, info, warn};
 
+use crate::cognitive::CognitiveEngine;
 use crate::protocol::messages::{
     CallToolRequest, CallToolResult, InitializeRequest, InitializeResult,
     ListResourcesResult, ListToolsResult, ReadResourceRequest, ReadResourceResult,
@@ -21,14 +23,19 @@ use vestige_core::Storage;
 /// MCP Server implementation
 pub struct McpServer {
     storage: Arc<Mutex<Storage>>,
+    cognitive: Arc<Mutex<CognitiveEngine>>,
     initialized: bool,
+    /// Tool call counter for inline consolidation trigger (every 100 calls)
+    tool_call_count: AtomicU64,
 }
 
 impl McpServer {
-    pub fn new(storage: Arc<Mutex<Storage>>) -> Self {
+    pub fn new(storage: Arc<Mutex<Storage>>, cognitive: Arc<Mutex<CognitiveEngine>>) -> Self {
         Self {
             storage,
+            cognitive,
             initialized: false,
+            tool_call_count: AtomicU64::new(0),
         }
     }
 
@@ -240,6 +247,32 @@ impl McpServer {
                 description: Some("Find duplicate and near-duplicate memory clusters using cosine similarity on embeddings. Returns clusters with suggested actions (merge/review). Use to clean up redundant memories.".to_string()),
                 input_schema: tools::dedup::schema(),
             },
+            // ================================================================
+            // COGNITIVE TOOLS (v1.5+)
+            // ================================================================
+            ToolDescription {
+                name: "dream".to_string(),
+                description: Some("Trigger memory dreaming — replays recent memories to discover hidden connections, synthesize insights, and strengthen important patterns. Returns insights, connections, and dream stats.".to_string()),
+                input_schema: tools::dream::schema(),
+            },
+            ToolDescription {
+                name: "explore_connections".to_string(),
+                description: Some("Graph exploration tool for memory connections. Actions: 'chain' (build reasoning path between memories), 'associations' (find related memories via spreading activation + hippocampal index), 'bridges' (find connecting memories between two nodes).".to_string()),
+                input_schema: tools::explore::schema(),
+            },
+            ToolDescription {
+                name: "predict".to_string(),
+                description: Some("Proactive memory prediction — predicts what memories you'll need next based on context, recent activity, and learned patterns. Returns predictions, suggestions, and speculative retrievals.".to_string()),
+                input_schema: tools::predict::schema(),
+            },
+            // ================================================================
+            // RESTORE TOOL (v1.5+)
+            // ================================================================
+            ToolDescription {
+                name: "restore".to_string(),
+                description: Some("Restore memories from a JSON backup file. Supports MCP wrapper format, RecallResult format, and direct memory array format.".to_string()),
+                input_schema: tools::restore::schema(),
+            },
         ];
 
         let result = ListToolsResult { tools };
@@ -256,20 +289,26 @@ impl McpServer {
             None => return Err(JsonRpcError::invalid_params("Missing tool call parameters")),
         };
 
+        // Record activity on every tool call (non-blocking)
+        if let Ok(mut cog) = self.cognitive.try_lock() {
+            cog.activity_tracker.record_activity();
+            cog.consolidation_scheduler.record_activity();
+        }
+
         let result = match request.name.as_str() {
             // ================================================================
             // UNIFIED TOOLS (v1.1+) - Preferred API
             // ================================================================
-            "search" => tools::search_unified::execute(&self.storage, request.arguments).await,
+            "search" => tools::search_unified::execute(&self.storage, &self.cognitive, request.arguments).await,
             "memory" => tools::memory_unified::execute(&self.storage, request.arguments).await,
-            "codebase" => tools::codebase_unified::execute(&self.storage, request.arguments).await,
-            "intention" => tools::intention_unified::execute(&self.storage, request.arguments).await,
+            "codebase" => tools::codebase_unified::execute(&self.storage, &self.cognitive, request.arguments).await,
+            "intention" => tools::intention_unified::execute(&self.storage, &self.cognitive, request.arguments).await,
 
             // ================================================================
             // Core memory tools
             // ================================================================
-            "ingest" => tools::ingest::execute(&self.storage, request.arguments).await,
-            "smart_ingest" => tools::smart_ingest::execute(&self.storage, request.arguments).await,
+            "ingest" => tools::ingest::execute(&self.storage, &self.cognitive, request.arguments).await,
+            "smart_ingest" => tools::smart_ingest::execute(&self.storage, &self.cognitive, request.arguments).await,
             "mark_reviewed" => tools::review::execute(&self.storage, request.arguments).await,
 
             // ================================================================
@@ -277,7 +316,7 @@ impl McpServer {
             // ================================================================
             "recall" | "semantic_search" | "hybrid_search" => {
                 warn!("Tool '{}' is deprecated. Use 'search' instead.", request.name);
-                tools::search_unified::execute(&self.storage, request.arguments).await
+                tools::search_unified::execute(&self.storage, &self.cognitive, request.arguments).await
             }
 
             // ================================================================
@@ -345,7 +384,7 @@ impl McpServer {
                     }
                     None => Some(serde_json::json!({"action": "remember_pattern"})),
                 };
-                tools::codebase_unified::execute(&self.storage, unified_args).await
+                tools::codebase_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
             "remember_decision" => {
                 warn!("Tool 'remember_decision' is deprecated. Use 'codebase' with action='remember_decision' instead.");
@@ -360,7 +399,7 @@ impl McpServer {
                     }
                     None => Some(serde_json::json!({"action": "remember_decision"})),
                 };
-                tools::codebase_unified::execute(&self.storage, unified_args).await
+                tools::codebase_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
             "get_codebase_context" => {
                 warn!("Tool 'get_codebase_context' is deprecated. Use 'codebase' with action='get_context' instead.");
@@ -375,7 +414,7 @@ impl McpServer {
                     }
                     None => Some(serde_json::json!({"action": "get_context"})),
                 };
-                tools::codebase_unified::execute(&self.storage, unified_args).await
+                tools::codebase_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
 
             // ================================================================
@@ -394,7 +433,7 @@ impl McpServer {
                     }
                     None => Some(serde_json::json!({"action": "set"})),
                 };
-                tools::intention_unified::execute(&self.storage, unified_args).await
+                tools::intention_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
             "check_intentions" => {
                 warn!("Tool 'check_intentions' is deprecated. Use 'intention' with action='check' instead.");
@@ -409,7 +448,7 @@ impl McpServer {
                     }
                     None => Some(serde_json::json!({"action": "check"})),
                 };
-                tools::intention_unified::execute(&self.storage, unified_args).await
+                tools::intention_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
             "complete_intention" => {
                 warn!("Tool 'complete_intention' is deprecated. Use 'intention' with action='update', status='complete' instead.");
@@ -425,7 +464,7 @@ impl McpServer {
                     }
                     None => None,
                 };
-                tools::intention_unified::execute(&self.storage, unified_args).await
+                tools::intention_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
             "snooze_intention" => {
                 warn!("Tool 'snooze_intention' is deprecated. Use 'intention' with action='update', status='snooze' instead.");
@@ -443,7 +482,7 @@ impl McpServer {
                     }
                     None => None,
                 };
-                tools::intention_unified::execute(&self.storage, unified_args).await
+                tools::intention_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
             "list_intentions" => {
                 warn!("Tool 'list_intentions' is deprecated. Use 'intention' with action='list' instead.");
@@ -462,7 +501,7 @@ impl McpServer {
                     }
                     None => Some(serde_json::json!({"action": "list"})),
                 };
-                tools::intention_unified::execute(&self.storage, unified_args).await
+                tools::intention_unified::execute(&self.storage, &self.cognitive, unified_args).await
             }
 
             // ================================================================
@@ -483,8 +522,8 @@ impl McpServer {
             // ================================================================
             // Feedback / preference learning (not deprecated)
             // ================================================================
-            "promote_memory" => tools::feedback::execute_promote(&self.storage, request.arguments).await,
-            "demote_memory" => tools::feedback::execute_demote(&self.storage, request.arguments).await,
+            "promote_memory" => tools::feedback::execute_promote(&self.storage, &self.cognitive, request.arguments).await,
+            "demote_memory" => tools::feedback::execute_demote(&self.storage, &self.cognitive, request.arguments).await,
             "request_feedback" => tools::feedback::execute_request_feedback(&self.storage, request.arguments).await,
 
             // ================================================================
@@ -498,7 +537,7 @@ impl McpServer {
             // ================================================================
             "health_check" => tools::maintenance::execute_health_check(&self.storage, request.arguments).await,
             "consolidate" => tools::maintenance::execute_consolidate(&self.storage, request.arguments).await,
-            "stats" => tools::maintenance::execute_stats(&self.storage, request.arguments).await,
+            "stats" => tools::maintenance::execute_stats(&self.storage, &self.cognitive, request.arguments).await,
             "backup" => tools::maintenance::execute_backup(&self.storage, request.arguments).await,
             "export" => tools::maintenance::execute_export(&self.storage, request.arguments).await,
             "gc" => tools::maintenance::execute_gc(&self.storage, request.arguments).await,
@@ -506,10 +545,18 @@ impl McpServer {
             // ================================================================
             // AUTO-SAVE & DEDUP TOOLS (v1.3+)
             // ================================================================
-            "importance_score" => tools::importance::execute(&self.storage, request.arguments).await,
+            "importance_score" => tools::importance::execute(&self.storage, &self.cognitive, request.arguments).await,
             "session_checkpoint" => tools::checkpoint::execute(&self.storage, request.arguments).await,
             "find_duplicates" => tools::dedup::execute(&self.storage, request.arguments).await,
 
+            // ================================================================
+            // COGNITIVE TOOLS (v1.5+)
+            // ================================================================
+            "dream" => tools::dream::execute(&self.storage, &self.cognitive, request.arguments).await,
+            "explore_connections" => tools::explore::execute(&self.storage, &self.cognitive, request.arguments).await,
+            "predict" => tools::predict::execute(&self.storage, &self.cognitive, request.arguments).await,
+            "restore" => tools::restore::execute(&self.storage, request.arguments).await,
+
             name => {
                 return Err(JsonRpcError::method_not_found_with_message(&format!(
                     "Unknown tool: {}",
@@ -518,7 +565,7 @@ impl McpServer {
             }
         };
 
-        match result {
+        let response = match result {
             Ok(content) => {
                 let call_result = CallToolResult {
                     content: vec![crate::protocol::messages::ToolResultContent {
@@ -539,7 +586,45 @@ impl McpServer {
                 };
                 serde_json::to_value(call_result).map_err(|e| JsonRpcError::internal_error(&e.to_string()))
             }
+        };
+
+        // Inline consolidation trigger: uses ConsolidationScheduler instead of fixed count
+        let count = self.tool_call_count.fetch_add(1, Ordering::Relaxed) + 1;
+        let should_consolidate = self.cognitive.try_lock()
+            .ok()
+            .map(|cog| cog.consolidation_scheduler.should_consolidate())
+            .unwrap_or(count % 100 == 0); // Fallback to count-based if lock unavailable
+
+        if should_consolidate {
+            let storage_clone = Arc::clone(&self.storage);
+            let cognitive_clone = Arc::clone(&self.cognitive);
+            tokio::spawn(async move {
+                // Expire labile reconsolidation windows
+                if let Ok(mut cog) = cognitive_clone.try_lock() {
+                    let _expired = cog.reconsolidation.reconsolidate_expired();
+                }
+
+                if let Ok(mut storage) = storage_clone.try_lock() {
+                    match storage.run_consolidation() {
+                        Ok(result) => {
+                            tracing::info!(
+                                tool_calls = count,
+                                decay_applied = result.decay_applied,
+                                duplicates_merged = result.duplicates_merged,
+                                activations_computed = result.activations_computed,
+                                duration_ms = result.duration_ms,
+                                "Inline consolidation triggered (scheduler)"
+                            );
+                        }
+                        Err(e) => {
+                            tracing::warn!("Inline consolidation failed: {}", e);
+                        }
+                    }
+                }
+            });
         }
+
+        response
     }
 
     /// Handle resources/list request
@@ -676,7 +761,8 @@ mod tests {
     /// Create a test server with temporary storage
     async fn test_server() -> (McpServer, TempDir) {
         let (storage, dir) = test_storage().await;
-        let server = McpServer::new(storage);
+        let cognitive = Arc::new(Mutex::new(CognitiveEngine::new()));
+        let server = McpServer::new(storage, cognitive);
         (server, dir)
     }
 
@@ -814,7 +900,7 @@ mod tests {
         let tools = result["tools"].as_array().unwrap();
 
         // v1.3+: 19 tools (8 unified + 2 temporal + 6 maintenance + 3 auto-save/dedup)
-        assert_eq!(tools.len(), 19, "Expected exactly 19 tools in v1.3+");
+        assert_eq!(tools.len(), 23, "Expected exactly 23 tools in v1.5+");
 
         let tool_names: Vec<&str> = tools
             .iter()
@@ -851,6 +937,12 @@ mod tests {
         assert!(tool_names.contains(&"importance_score"));
         assert!(tool_names.contains(&"session_checkpoint"));
         assert!(tool_names.contains(&"find_duplicates"));
+
+        // Cognitive tools (v1.5)
+        assert!(tool_names.contains(&"dream"));
+        assert!(tool_names.contains(&"explore_connections"));
+        assert!(tool_names.contains(&"predict"));
+        assert!(tool_names.contains(&"restore"));
     }
 
     #[tokio::test]

crates/vestige-mcp/src/tools/changelog.rs

@@ -44,6 +44,7 @@ pub fn schema() -> Value {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct ChangelogArgs {
+    #[serde(alias = "memory_id")]
     memory_id: Option<String>,
     #[allow(dead_code)]
     start: Option<String>,
@@ -189,3 +190,126 @@ fn execute_system_wide(
         "events": formatted_events,
     }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    async fn ingest_test_memory(storage: &Arc<Mutex<Storage>>) -> String {
+        let mut s = storage.lock().await;
+        let node = s
+            .ingest(vestige_core::IngestInput {
+                content: "Changelog test memory".to_string(),
+                node_type: "fact".to_string(),
+                source: None,
+                sentiment_score: 0.0,
+                sentiment_magnitude: 0.0,
+                tags: vec![],
+                valid_from: None,
+                valid_until: None,
+            })
+            .unwrap();
+        node.id
+    }
+
+    #[test]
+    fn test_schema_has_properties() {
+        let s = schema();
+        assert_eq!(s["type"], "object");
+        assert!(s["properties"]["memory_id"].is_object());
+        assert!(s["properties"]["start"].is_object());
+        assert!(s["properties"]["end"].is_object());
+        assert!(s["properties"]["limit"].is_object());
+        assert_eq!(s["properties"]["limit"]["default"], 20);
+        assert_eq!(s["properties"]["limit"]["minimum"], 1);
+        assert_eq!(s["properties"]["limit"]["maximum"], 100);
+    }
+
+    #[tokio::test]
+    async fn test_changelog_no_args_system_wide() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["tool"], "memory_changelog");
+        assert_eq!(value["mode"], "system_wide");
+        assert!(value["events"].is_array());
+    }
+
+    #[tokio::test]
+    async fn test_changelog_system_wide_empty() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        let value = result.unwrap();
+        assert_eq!(value["totalEvents"], 0);
+        assert!(value["events"].as_array().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_changelog_per_memory_valid_id() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "memory_id": id });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["tool"], "memory_changelog");
+        assert_eq!(value["mode"], "per_memory");
+        assert_eq!(value["memoryId"], id);
+        assert!(value["memoryContent"].is_string());
+        assert!(value["transitions"].is_array());
+    }
+
+    #[tokio::test]
+    async fn test_changelog_per_memory_invalid_uuid() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "memory_id": "not-a-uuid" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid memory_id"));
+    }
+
+    #[tokio::test]
+    async fn test_changelog_per_memory_nonexistent() {
+        let (storage, _dir) = test_storage().await;
+        let args =
+            serde_json::json!({ "memory_id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("not found"));
+    }
+
+    #[tokio::test]
+    async fn test_changelog_limit_clamped() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "limit": 0 });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok()); // clamped to 1
+    }
+
+    #[tokio::test]
+    async fn test_changelog_limit_high_clamped() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "limit": 999 });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok()); // clamped to 100
+    }
+
+    #[tokio::test]
+    async fn test_changelog_per_memory_no_transitions() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "memory_id": id });
+        let result = execute(&storage, Some(args)).await;
+        let value = result.unwrap();
+        assert_eq!(value["totalTransitions"], 0);
+        assert!(value["transitions"].as_array().unwrap().is_empty());
+    }
+}

crates/vestige-mcp/src/tools/checkpoint.rs

@@ -237,4 +237,133 @@ mod tests {
         let value = result.unwrap();
         assert_eq!(value["summary"]["skipped"], 1);
     }
+
+    #[tokio::test]
+    async fn test_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_exceeds_20_items_fails() {
+        let (storage, _dir) = test_storage().await;
+        let items: Vec<serde_json::Value> = (0..21)
+            .map(|i| serde_json::json!({ "content": format!("Item {}", i) }))
+            .collect();
+        let result = execute(&storage, Some(serde_json::json!({ "items": items }))).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Maximum 20 items"));
+    }
+
+    #[tokio::test]
+    async fn test_exactly_20_items_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let items: Vec<serde_json::Value> = (0..20)
+            .map(|i| serde_json::json!({ "content": format!("Item {}", i) }))
+            .collect();
+        let result = execute(&storage, Some(serde_json::json!({ "items": items }))).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["summary"]["total"], 20);
+    }
+
+    #[tokio::test]
+    async fn test_skips_whitespace_only_content() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(
+            &storage,
+            Some(serde_json::json!({
+                "items": [
+                    { "content": "   \t\n  " },
+                    { "content": "Valid content" }
+                ]
+            })),
+        )
+        .await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["summary"]["skipped"], 1);
+        assert_eq!(value["summary"]["created"], 1);
+    }
+
+    #[tokio::test]
+    async fn test_single_item_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(
+            &storage,
+            Some(serde_json::json!({
+                "items": [{ "content": "Single item" }]
+            })),
+        )
+        .await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["summary"]["total"], 1);
+        assert_eq!(value["success"], true);
+    }
+
+    #[tokio::test]
+    async fn test_items_with_all_fields() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(
+            &storage,
+            Some(serde_json::json!({
+                "items": [{
+                    "content": "Full fields item",
+                    "tags": ["test", "checkpoint"],
+                    "node_type": "decision",
+                    "source": "test-suite"
+                }]
+            })),
+        )
+        .await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["summary"]["created"], 1);
+    }
+
+    #[tokio::test]
+    async fn test_results_array_matches_items() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(
+            &storage,
+            Some(serde_json::json!({
+                "items": [
+                    { "content": "First" },
+                    { "content": "" },
+                    { "content": "Third" }
+                ]
+            })),
+        )
+        .await;
+        let value = result.unwrap();
+        let results = value["results"].as_array().unwrap();
+        assert_eq!(results.len(), 3);
+        assert_eq!(results[0]["index"], 0);
+        assert_eq!(results[1]["index"], 1);
+        assert_eq!(results[1]["status"], "skipped");
+        assert_eq!(results[2]["index"], 2);
+    }
+
+    #[tokio::test]
+    async fn test_success_false_when_errors() {
+        // All items empty = all skipped = 0 errors = success true
+        let (storage, _dir) = test_storage().await;
+        let result = execute(
+            &storage,
+            Some(serde_json::json!({
+                "items": [
+                    { "content": "" },
+                    { "content": "   " }
+                ]
+            })),
+        )
+        .await;
+        let value = result.unwrap();
+        assert_eq!(value["success"], true); // skipped ≠ errors
+        assert_eq!(value["summary"]["errors"], 0);
+        assert_eq!(value["summary"]["skipped"], 2);
+    }
 }

crates/vestige-mcp/src/tools/codebase_unified.rs

@@ -8,6 +8,7 @@ use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+use crate::cognitive::CognitiveEngine;
 use vestige_core::{IngestInput, Storage};
 
 /// Input schema for the unified codebase tool
@@ -85,6 +86,7 @@ struct CodebaseArgs {
 /// Execute the unified codebase tool
 pub async fn execute(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: CodebaseArgs = match args {
@@ -93,9 +95,9 @@ pub async fn execute(
     };
 
     match args.action.as_str() {
-        "remember_pattern" => execute_remember_pattern(storage, &args).await,
-        "remember_decision" => execute_remember_decision(storage, &args).await,
-        "get_context" => execute_get_context(storage, &args).await,
+        "remember_pattern" => execute_remember_pattern(storage, cognitive, &args).await,
+        "remember_decision" => execute_remember_decision(storage, cognitive, &args).await,
+        "get_context" => execute_get_context(storage, cognitive, &args).await,
         _ => Err(format!(
             "Invalid action '{}'. Must be one of: remember_pattern, remember_decision, get_context",
             args.action
@@ -106,6 +108,7 @@ pub async fn execute(
 /// Remember a code pattern
 async fn execute_remember_pattern(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: &CodebaseArgs,
 ) -> Result<Value, String> {
     let name = args
@@ -152,11 +155,30 @@ async fn execute_remember_pattern(
 
     let mut storage = storage.lock().await;
     let node = storage.ingest(input).map_err(|e| e.to_string())?;
+    let node_id = node.id.clone();
+    drop(storage);
+
+    // ====================================================================
+    // COGNITIVE: Cross-project pattern recording
+    // ====================================================================
+    if let Ok(cog) = cognitive.try_lock() {
+        let codebase_name = args.codebase.as_deref().unwrap_or("default");
+        cog.cross_project.record_project_memory(&node_id, codebase_name, None);
+
+        // Also index in hippocampal index for fast retrieval
+        let _ = cog.hippocampal_index.index_memory(
+            &node_id,
+            &format!("{}: {}", name, description),
+            "pattern",
+            chrono::Utc::now(),
+            None,
+        );
+    }
 
     Ok(serde_json::json!({
         "action": "remember_pattern",
         "success": true,
-        "nodeId": node.id,
+        "nodeId": node_id,
         "patternName": name,
         "message": format!("Pattern '{}' remembered successfully", name),
     }))
@@ -165,6 +187,7 @@ async fn execute_remember_pattern(
 /// Remember an architectural decision
 async fn execute_remember_decision(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: &CodebaseArgs,
 ) -> Result<Value, String> {
     let decision = args
@@ -229,11 +252,30 @@ async fn execute_remember_decision(
 
     let mut storage = storage.lock().await;
     let node = storage.ingest(input).map_err(|e| e.to_string())?;
+    let node_id = node.id.clone();
+    drop(storage);
+
+    // ====================================================================
+    // COGNITIVE: Cross-project decision recording
+    // ====================================================================
+    if let Ok(cog) = cognitive.try_lock() {
+        let codebase_name = args.codebase.as_deref().unwrap_or("default");
+        cog.cross_project.record_project_memory(&node_id, codebase_name, None);
+
+        // Index in hippocampal index
+        let _ = cog.hippocampal_index.index_memory(
+            &node_id,
+            &format!("Decision: {}", decision),
+            "decision",
+            chrono::Utc::now(),
+            None,
+        );
+    }
 
     Ok(serde_json::json!({
         "action": "remember_decision",
         "success": true,
-        "nodeId": node.id,
+        "nodeId": node_id,
         "message": "Architectural decision remembered successfully",
     }))
 }
@@ -241,14 +283,13 @@ async fn execute_remember_decision(
 /// Get codebase context (patterns and decisions)
 async fn execute_get_context(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: &CodebaseArgs,
 ) -> Result<Value, String> {
     let limit = args.limit.unwrap_or(10).clamp(1, 50);
     let storage = storage.lock().await;
 
     // Build tag filter for codebase
-    // Tags are stored as: ["pattern", "codebase", "codebase:vestige"]
-    // We search for the "codebase:{name}" tag
     let tag_filter = args
         .codebase
         .as_ref()
@@ -263,6 +304,7 @@ async fn execute_get_context(
     let decisions = storage
         .get_nodes_by_type_and_tag("decision", tag_filter.as_deref(), limit)
         .unwrap_or_default();
+    drop(storage);
 
     let formatted_patterns: Vec<Value> = patterns
         .iter()
@@ -290,6 +332,30 @@ async fn execute_get_context(
         })
         .collect();
 
+    // ====================================================================
+    // COGNITIVE: Cross-project knowledge discovery
+    // ====================================================================
+    let mut universal_patterns = Vec::new();
+    if let Some(codebase_name) = &args.codebase {
+        if let Ok(cog) = cognitive.try_lock() {
+            let context = vestige_core::advanced::cross_project::ProjectContext {
+                path: None,
+                name: Some(codebase_name.clone()),
+                languages: Vec::new(),
+                frameworks: Vec::new(),
+                file_types: std::collections::HashSet::new(),
+                dependencies: Vec::new(),
+                structure: Vec::new(),
+            };
+            let applicable = cog.cross_project.detect_applicable(&context);
+            for knowledge in applicable {
+                universal_patterns.push(serde_json::json!({
+                    "pattern": format!("{:?}", knowledge),
+                }));
+            }
+        }
+    }
+
     Ok(serde_json::json!({
         "action": "get_context",
         "codebase": args.codebase,
@@ -301,6 +367,7 @@ async fn execute_get_context(
             "count": formatted_decisions.len(),
             "items": formatted_decisions,
         },
+        "crossProjectInsights": universal_patterns,
     }))
 }
 
@@ -329,4 +396,195 @@ mod tests {
             .unwrap()
             .contains(&serde_json::json!("get_context")));
     }
+
+    // === INTEGRATION TESTS ===
+
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, tempfile::TempDir) {
+        let dir = tempfile::TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    #[tokio::test]
+    async fn test_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_invalid_action_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "invalid" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid action"));
+    }
+
+    #[tokio::test]
+    async fn test_remember_pattern_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_pattern",
+            "name": "Error Handling Pattern",
+            "description": "Use Result<T, E> with custom error types",
+            "files": ["src/lib.rs"],
+            "codebase": "vestige"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "remember_pattern");
+        assert_eq!(value["success"], true);
+        assert!(value["nodeId"].is_string());
+        assert_eq!(value["patternName"], "Error Handling Pattern");
+    }
+
+    #[tokio::test]
+    async fn test_remember_pattern_missing_name_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_pattern",
+            "description": "Some description"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("'name' is required"));
+    }
+
+    #[tokio::test]
+    async fn test_remember_pattern_missing_description_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_pattern",
+            "name": "Test Pattern"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("'description' is required"));
+    }
+
+    #[tokio::test]
+    async fn test_remember_pattern_empty_name_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_pattern",
+            "name": "   ",
+            "description": "Some description"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("empty"));
+    }
+
+    #[tokio::test]
+    async fn test_remember_decision_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_decision",
+            "decision": "Use SQLite for storage",
+            "rationale": "Embedded, no separate server needed",
+            "alternatives": ["PostgreSQL", "Redis"],
+            "files": ["src/storage.rs"],
+            "codebase": "vestige"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "remember_decision");
+        assert_eq!(value["success"], true);
+        assert!(value["nodeId"].is_string());
+    }
+
+    #[tokio::test]
+    async fn test_remember_decision_missing_decision_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_decision",
+            "rationale": "Some rationale"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("'decision' is required"));
+    }
+
+    #[tokio::test]
+    async fn test_remember_decision_missing_rationale_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_decision",
+            "decision": "Use SQLite"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("'rationale' is required"));
+    }
+
+    #[tokio::test]
+    async fn test_remember_decision_empty_decision_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "remember_decision",
+            "decision": "  ",
+            "rationale": "Something"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("empty"));
+    }
+
+    #[tokio::test]
+    async fn test_get_context_empty() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "get_context",
+            "codebase": "nonexistent"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "get_context");
+        assert_eq!(value["patterns"]["count"], 0);
+        assert_eq!(value["decisions"]["count"], 0);
+    }
+
+    #[tokio::test]
+    async fn test_get_context_retrieves_saved_patterns() {
+        let (storage, _dir) = test_storage().await;
+        let cog = test_cognitive();
+        // Save a pattern first
+        let save_args = serde_json::json!({
+            "action": "remember_pattern",
+            "name": "Test Pattern",
+            "description": "A test pattern",
+            "codebase": "myproject"
+        });
+        execute(&storage, &cog, Some(save_args)).await.unwrap();
+
+        // Now retrieve
+        let get_args = serde_json::json!({
+            "action": "get_context",
+            "codebase": "myproject"
+        });
+        let result = execute(&storage, &cog, Some(get_args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert!(value["patterns"]["count"].as_u64().unwrap() >= 1);
+    }
+
+    #[tokio::test]
+    async fn test_get_context_no_codebase() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "get_context" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "get_context");
+        assert!(value["codebase"].is_null());
+    }
 }

crates/vestige-mcp/src/tools/dream.rs

@@ -0,0 +1,192 @@
+//! Dream tool — Explicit dream trigger that returns insights.
+//! v1.5.0: Wires MemoryDreamer into an MCP tool.
+
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use crate::cognitive::CognitiveEngine;
+use vestige_core::Storage;
+
+pub fn schema() -> serde_json::Value {
+    serde_json::json!({
+        "type": "object",
+        "properties": {
+            "memory_count": {
+                "type": "integer",
+                "description": "Number of recent memories to dream about (default: 50)",
+                "default": 50
+            }
+        }
+    })
+}
+
+pub async fn execute(
+    storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
+    args: Option<serde_json::Value>,
+) -> Result<serde_json::Value, String> {
+    let memory_count = args
+        .as_ref()
+        .and_then(|a| a.get("memory_count"))
+        .and_then(|v| v.as_u64())
+        .unwrap_or(50) as usize;
+
+    let storage = storage.lock().await;
+    let all_nodes = storage.get_all_nodes(memory_count as i32, 0)
+        .map_err(|e| format!("Failed to load memories: {}", e))?;
+
+    if all_nodes.len() < 5 {
+        return Ok(serde_json::json!({
+            "status": "insufficient_memories",
+            "message": format!("Need at least 5 memories to dream. Current count: {}", all_nodes.len()),
+            "count": all_nodes.len()
+        }));
+    }
+
+    let dream_memories: Vec<vestige_core::DreamMemory> = all_nodes.iter().map(|n| {
+        vestige_core::DreamMemory {
+            id: n.id.clone(),
+            content: n.content.clone(),
+            embedding: storage.get_node_embedding(&n.id).ok().flatten(),
+            tags: n.tags.clone(),
+            created_at: n.created_at,
+            access_count: n.reps as u32,
+        }
+    }).collect();
+    // Drop storage lock before taking cognitive lock (strict ordering)
+    drop(storage);
+
+    let cog = cognitive.lock().await;
+    let dream_result = cog.dreamer.dream(&dream_memories).await;
+    let insights = cog.dreamer.synthesize_insights(&dream_memories);
+
+    Ok(serde_json::json!({
+        "status": "dreamed",
+        "memoriesReplayed": dream_memories.len(),
+        "insights": insights.iter().map(|i| serde_json::json!({
+            "insight_type": format!("{:?}", i.insight_type),
+            "insight": i.insight,
+            "source_memories": i.source_memories,
+            "confidence": i.confidence,
+            "novelty_score": i.novelty_score,
+        })).collect::<Vec<_>>(),
+        "stats": {
+            "new_connections_found": dream_result.new_connections_found,
+            "memories_strengthened": dream_result.memories_strengthened,
+            "memories_compressed": dream_result.memories_compressed,
+            "insights_generated": dream_result.insights_generated.len(),
+            "duration_ms": dream_result.duration_ms,
+        }
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cognitive::CognitiveEngine;
+    use tempfile::TempDir;
+
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    async fn ingest_n_memories(storage: &Arc<Mutex<Storage>>, n: usize) {
+        let mut s = storage.lock().await;
+        for i in 0..n {
+            s.ingest(vestige_core::IngestInput {
+                content: format!("Dream test memory number {}", i),
+                node_type: "fact".to_string(),
+                source: None,
+                sentiment_score: 0.0,
+                sentiment_magnitude: 0.0,
+                tags: vec!["dream-test".to_string()],
+                valid_from: None,
+                valid_until: None,
+            })
+            .unwrap();
+        }
+    }
+
+    #[test]
+    fn test_schema_has_properties() {
+        let s = schema();
+        assert_eq!(s["type"], "object");
+        assert!(s["properties"]["memory_count"].is_object());
+        assert_eq!(s["properties"]["memory_count"]["default"], 50);
+    }
+
+    #[tokio::test]
+    async fn test_dream_insufficient_memories() {
+        let (storage, _dir) = test_storage().await;
+        ingest_n_memories(&storage, 3).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["status"], "insufficient_memories");
+        assert_eq!(value["count"], 3);
+    }
+
+    #[tokio::test]
+    async fn test_dream_empty_database() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["status"], "insufficient_memories");
+        assert_eq!(value["count"], 0);
+    }
+
+    #[tokio::test]
+    async fn test_dream_with_enough_memories() {
+        let (storage, _dir) = test_storage().await;
+        ingest_n_memories(&storage, 10).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["status"], "dreamed");
+        assert!(value["memoriesReplayed"].as_u64().unwrap() >= 5);
+        assert!(value["insights"].is_array());
+        assert!(value["stats"].is_object());
+    }
+
+    #[tokio::test]
+    async fn test_dream_custom_memory_count() {
+        let (storage, _dir) = test_storage().await;
+        ingest_n_memories(&storage, 10).await;
+        let args = serde_json::json!({ "memory_count": 7 });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["status"], "dreamed");
+        assert!(value["memoriesReplayed"].as_u64().unwrap() <= 7);
+    }
+
+    #[tokio::test]
+    async fn test_dream_with_exactly_5_memories() {
+        let (storage, _dir) = test_storage().await;
+        ingest_n_memories(&storage, 5).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["status"], "dreamed");
+    }
+
+    #[tokio::test]
+    async fn test_dream_stats_fields_present() {
+        let (storage, _dir) = test_storage().await;
+        ingest_n_memories(&storage, 6).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        let value = result.unwrap();
+        assert!(value["stats"]["new_connections_found"].is_number());
+        assert!(value["stats"]["memories_strengthened"].is_number());
+        assert!(value["stats"]["memories_compressed"].is_number());
+        assert!(value["stats"]["insights_generated"].is_number());
+        assert!(value["stats"]["duration_ms"].is_number());
+    }
+}

crates/vestige-mcp/src/tools/explore.rs

@@ -0,0 +1,277 @@
+//! Explore connections tool — Graph exploration, chain building, bridge discovery.
+//! v1.5.0: Wires MemoryChainBuilder + ActivationNetwork + HippocampalIndex.
+
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use crate::cognitive::CognitiveEngine;
+use vestige_core::Storage;
+
+pub fn schema() -> serde_json::Value {
+    serde_json::json!({
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["chain", "associations", "bridges"],
+                "description": "Type of exploration: 'chain' builds reasoning path, 'associations' finds related memories, 'bridges' finds connecting memories"
+            },
+            "from": {
+                "type": "string",
+                "description": "Source memory ID"
+            },
+            "to": {
+                "type": "string",
+                "description": "Target memory ID (required for 'chain' and 'bridges')"
+            },
+            "limit": {
+                "type": "integer",
+                "description": "Maximum results (default: 10)",
+                "default": 10
+            }
+        },
+        "required": ["action", "from"]
+    })
+}
+
+pub async fn execute(
+    _storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
+    args: Option<serde_json::Value>,
+) -> Result<serde_json::Value, String> {
+    let args = args.ok_or("Missing arguments")?;
+    let action = args.get("action").and_then(|v| v.as_str()).ok_or("Missing 'action'")?;
+    let from = args.get("from").and_then(|v| v.as_str()).ok_or("Missing 'from'")?;
+    let to = args.get("to").and_then(|v| v.as_str());
+    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(10) as usize;
+
+    let cog = cognitive.lock().await;
+
+    match action {
+        "chain" => {
+            let to_id = to.ok_or("'to' is required for chain action")?;
+            match cog.chain_builder.build_chain(from, to_id) {
+                Some(chain) => {
+                    Ok(serde_json::json!({
+                        "action": "chain",
+                        "from": from,
+                        "to": to_id,
+                        "steps": chain.steps.iter().map(|s| serde_json::json!({
+                            "memory_id": s.memory_id,
+                            "memory_preview": s.memory_preview,
+                            "connection_type": format!("{:?}", s.connection_type),
+                            "connection_strength": s.connection_strength,
+                            "reasoning": s.reasoning,
+                        })).collect::<Vec<_>>(),
+                        "confidence": chain.confidence,
+                        "total_hops": chain.total_hops,
+                    }))
+                }
+                None => {
+                    Ok(serde_json::json!({
+                        "action": "chain",
+                        "from": from,
+                        "to": to_id,
+                        "steps": [],
+                        "message": "No chain found between these memories"
+                    }))
+                }
+            }
+        }
+        "associations" => {
+            let activation_assocs = cog.activation_network.get_associations(from);
+            let hippocampal_assocs = cog.hippocampal_index.get_associations(from, 2)
+                .unwrap_or_default();
+
+            let mut all_associations: Vec<serde_json::Value> = Vec::new();
+
+            for assoc in activation_assocs.iter().take(limit) {
+                all_associations.push(serde_json::json!({
+                    "memory_id": assoc.memory_id,
+                    "strength": assoc.association_strength,
+                    "link_type": format!("{:?}", assoc.link_type),
+                    "source": "spreading_activation",
+                }));
+            }
+            for m in hippocampal_assocs.iter().take(limit) {
+                all_associations.push(serde_json::json!({
+                    "memory_id": m.index.memory_id,
+                    "semantic_score": m.semantic_score,
+                    "text_score": m.text_score,
+                    "source": "hippocampal_index",
+                }));
+            }
+
+            all_associations.truncate(limit);
+
+            Ok(serde_json::json!({
+                "action": "associations",
+                "from": from,
+                "associations": all_associations,
+                "count": all_associations.len(),
+            }))
+        }
+        "bridges" => {
+            let to_id = to.ok_or("'to' is required for bridges action")?;
+            let bridges = cog.chain_builder.find_bridge_memories(from, to_id);
+            let limited: Vec<_> = bridges.iter().take(limit).collect();
+            Ok(serde_json::json!({
+                "action": "bridges",
+                "from": from,
+                "to": to_id,
+                "bridges": limited,
+                "count": limited.len(),
+            }))
+        }
+        _ => Err(format!("Unknown action: '{}'. Expected: chain, associations, bridges", action)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cognitive::CognitiveEngine;
+    use tempfile::TempDir;
+
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    #[test]
+    fn test_schema_has_required_fields() {
+        let s = schema();
+        assert_eq!(s["type"], "object");
+        assert!(s["properties"]["action"].is_object());
+        assert!(s["properties"]["from"].is_object());
+        assert!(s["properties"]["to"].is_object());
+        assert!(s["properties"]["limit"].is_object());
+        let required = s["required"].as_array().unwrap();
+        assert!(required.contains(&serde_json::json!("action")));
+        assert!(required.contains(&serde_json::json!("from")));
+    }
+
+    #[test]
+    fn test_schema_action_enum() {
+        let s = schema();
+        let action_enum = s["properties"]["action"]["enum"].as_array().unwrap();
+        assert!(action_enum.contains(&serde_json::json!("chain")));
+        assert!(action_enum.contains(&serde_json::json!("associations")));
+        assert!(action_enum.contains(&serde_json::json!("bridges")));
+    }
+
+    #[tokio::test]
+    async fn test_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_missing_action_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "from": "some-id" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing 'action'"));
+    }
+
+    #[tokio::test]
+    async fn test_missing_from_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "associations" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing 'from'"));
+    }
+
+    #[tokio::test]
+    async fn test_unknown_action_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "invalid", "from": "id1" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Unknown action"));
+    }
+
+    #[tokio::test]
+    async fn test_chain_missing_to_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "chain", "from": "id1" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("'to' is required"));
+    }
+
+    #[tokio::test]
+    async fn test_bridges_missing_to_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "bridges", "from": "id1" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("'to' is required"));
+    }
+
+    #[tokio::test]
+    async fn test_associations_succeeds_empty() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "associations",
+            "from": "00000000-0000-0000-0000-000000000000"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "associations");
+        assert!(value["associations"].is_array());
+        assert_eq!(value["count"], 0);
+    }
+
+    #[tokio::test]
+    async fn test_chain_no_path_found() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "chain",
+            "from": "00000000-0000-0000-0000-000000000001",
+            "to": "00000000-0000-0000-0000-000000000002"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "chain");
+        assert_eq!(value["steps"].as_array().unwrap().len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_bridges_no_results() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "bridges",
+            "from": "00000000-0000-0000-0000-000000000001",
+            "to": "00000000-0000-0000-0000-000000000002"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "bridges");
+        assert_eq!(value["count"], 0);
+    }
+
+    #[tokio::test]
+    async fn test_associations_with_limit() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "action": "associations",
+            "from": "00000000-0000-0000-0000-000000000000",
+            "limit": 5
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+    }
+}

crates/vestige-mcp/src/tools/feedback.rs

@@ -1,15 +1,22 @@
 #![allow(dead_code)]
-//! Feedback Tools (Deprecated - use promote_memory/demote_memory instead)
+//! Feedback Tools
 //!
 //! Promote and demote memories based on outcome quality.
 //! Implements preference learning for Vestige.
+//!
+//! v1.5.0: Enhanced with cognitive pipeline:
+//!   - Reward signal recording (4-channel importance)
+//!   - Importance tracking (retrieval outcome)
+//!   - Reconsolidation modification (labile window boost)
+//!   - Activation network reinforcement
 
 use serde::Deserialize;
 use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use vestige_core::Storage;
+use crate::cognitive::CognitiveEngine;
+use vestige_core::{Modification, OutcomeType, Storage};
 
 /// Input schema for promote_memory tool
 pub fn promote_schema() -> Value {
@@ -56,6 +63,7 @@ struct FeedbackArgs {
 /// Promote a memory (thumbs up) - it led to a good outcome
 pub async fn execute_promote(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: FeedbackArgs = match args {
@@ -66,13 +74,36 @@ pub async fn execute_promote(
     // Validate UUID
     uuid::Uuid::parse_str(&args.id).map_err(|_| "Invalid node ID format".to_string())?;
 
-    let storage = storage.lock().await;
+    let storage_guard = storage.lock().await;
 
     // Get node before for comparison
-    let before = storage.get_node(&args.id).map_err(|e| e.to_string())?
+    let before = storage_guard.get_node(&args.id).map_err(|e| e.to_string())?
         .ok_or_else(|| format!("Node not found: {}", args.id))?;
 
-    let node = storage.promote_memory(&args.id).map_err(|e| e.to_string())?;
+    let node = storage_guard.promote_memory(&args.id).map_err(|e| e.to_string())?;
+    drop(storage_guard);
+
+    // ====================================================================
+    // COGNITIVE FEEDBACK PIPELINE (promote)
+    // ====================================================================
+    if let Ok(mut cog) = cognitive.try_lock() {
+        // 5A. Reward signal — record positive outcome
+        cog.reward_signal.record_outcome(&args.id, OutcomeType::Helpful);
+
+        // 5B. Importance tracking — mark as helpful retrieval
+        cog.importance_tracker.on_retrieved(&args.id, true);
+
+        // 5C. Reconsolidation — boost retrieval if memory is labile
+        if cog.reconsolidation.is_labile(&args.id) {
+            cog.reconsolidation.apply_modification(
+                &args.id,
+                Modification::StrengthenConnection {
+                    target_memory_id: args.id.clone(),
+                    boost: 0.2,
+                },
+            );
+        }
+    }
 
     Ok(serde_json::json!({
         "success": true,
@@ -104,6 +135,7 @@ pub async fn execute_promote(
 /// Demote a memory (thumbs down) - it led to a bad outcome
 pub async fn execute_demote(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: FeedbackArgs = match args {
@@ -114,13 +146,35 @@ pub async fn execute_demote(
     // Validate UUID
     uuid::Uuid::parse_str(&args.id).map_err(|_| "Invalid node ID format".to_string())?;
 
-    let storage = storage.lock().await;
+    let storage_guard = storage.lock().await;
 
     // Get node before for comparison
-    let before = storage.get_node(&args.id).map_err(|e| e.to_string())?
+    let before = storage_guard.get_node(&args.id).map_err(|e| e.to_string())?
         .ok_or_else(|| format!("Node not found: {}", args.id))?;
 
-    let node = storage.demote_memory(&args.id).map_err(|e| e.to_string())?;
+    let node = storage_guard.demote_memory(&args.id).map_err(|e| e.to_string())?;
+    drop(storage_guard);
+
+    // ====================================================================
+    // COGNITIVE FEEDBACK PIPELINE (demote)
+    // ====================================================================
+    if let Ok(mut cog) = cognitive.try_lock() {
+        // 5A. Reward signal — record negative outcome
+        cog.reward_signal.record_outcome(&args.id, OutcomeType::NotHelpful);
+
+        // 5B. Importance tracking — mark as unhelpful retrieval
+        cog.importance_tracker.on_retrieved(&args.id, false);
+
+        // 5C. Reconsolidation — weaken if memory is labile
+        if cog.reconsolidation.is_labile(&args.id) {
+            cog.reconsolidation.apply_modification(
+                &args.id,
+                Modification::AddContext {
+                    context: "User reported this memory was wrong/unhelpful".to_string(),
+                },
+            );
+        }
+    }
 
     Ok(serde_json::json!({
         "success": true,
@@ -230,3 +284,285 @@ pub async fn execute_request_feedback(
         "instruction": "PRESENT THESE OPTIONS TO THE USER. If they choose A, call promote_memory. If B, call demote_memory. If C, they will provide a custom instruction - execute it (could be: update the memory content, delete it, merge it, add tags, research something, etc.)."
     }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cognitive::CognitiveEngine;
+    use tempfile::TempDir;
+
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    async fn ingest_test_memory(storage: &Arc<Mutex<Storage>>) -> String {
+        let mut s = storage.lock().await;
+        let node = s
+            .ingest(vestige_core::IngestInput {
+                content: "Test memory for feedback".to_string(),
+                node_type: "fact".to_string(),
+                source: None,
+                sentiment_score: 0.0,
+                sentiment_magnitude: 0.0,
+                tags: vec![],
+                valid_from: None,
+                valid_until: None,
+            })
+            .unwrap();
+        node.id
+    }
+
+    // === PROMOTE SCHEMA ===
+
+    #[test]
+    fn test_promote_schema_has_required_fields() {
+        let schema = promote_schema();
+        assert_eq!(schema["type"], "object");
+        assert!(schema["properties"]["id"].is_object());
+        assert!(schema["properties"]["reason"].is_object());
+        assert!(schema["required"]
+            .as_array()
+            .unwrap()
+            .contains(&serde_json::json!("id")));
+    }
+
+    #[test]
+    fn test_demote_schema_has_required_fields() {
+        let schema = demote_schema();
+        assert_eq!(schema["type"], "object");
+        assert!(schema["properties"]["id"].is_object());
+        assert!(schema["required"]
+            .as_array()
+            .unwrap()
+            .contains(&serde_json::json!("id")));
+    }
+
+    #[test]
+    fn test_request_feedback_schema_has_required_fields() {
+        let schema = request_feedback_schema();
+        assert_eq!(schema["type"], "object");
+        assert!(schema["properties"]["id"].is_object());
+        assert!(schema["properties"]["context"].is_object());
+        assert!(schema["required"]
+            .as_array()
+            .unwrap()
+            .contains(&serde_json::json!("id")));
+    }
+
+    // === PROMOTE TESTS ===
+
+    #[tokio::test]
+    async fn test_promote_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute_promote(&storage, &test_cognitive(), None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_promote_invalid_uuid_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "id": "not-a-uuid" });
+        let result = execute_promote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid node ID format"));
+    }
+
+    #[tokio::test]
+    async fn test_promote_nonexistent_node_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args =
+            serde_json::json!({ "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute_promote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Node not found"));
+    }
+
+    #[tokio::test]
+    async fn test_promote_missing_id_field_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "reason": "test" });
+        let result = execute_promote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_promote_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "id": id, "reason": "It was helpful" });
+        let result = execute_promote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["success"], true);
+        assert_eq!(value["action"], "promoted");
+        assert_eq!(value["nodeId"], id);
+        assert_eq!(value["reason"], "It was helpful");
+        assert!(value["changes"]["retrievalStrength"].is_object());
+    }
+
+    #[tokio::test]
+    async fn test_promote_without_reason_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "id": id });
+        let result = execute_promote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["success"], true);
+        assert!(value["reason"].is_null());
+    }
+
+    #[tokio::test]
+    async fn test_promote_changes_contain_expected_fields() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "id": id });
+        let result = execute_promote(&storage, &test_cognitive(), Some(args)).await;
+        let value = result.unwrap();
+        // Verify response structure includes before/after/delta for all 3 metrics
+        assert!(value["changes"]["retrievalStrength"]["before"].is_number());
+        assert!(value["changes"]["retrievalStrength"]["after"].is_number());
+        assert_eq!(value["changes"]["retrievalStrength"]["delta"], "+0.20");
+        assert!(value["changes"]["retentionStrength"]["before"].is_number());
+        assert!(value["changes"]["retentionStrength"]["after"].is_number());
+        assert_eq!(value["changes"]["retentionStrength"]["delta"], "+0.10");
+        assert!(value["changes"]["stability"]["before"].is_number());
+        assert!(value["changes"]["stability"]["after"].is_number());
+        assert_eq!(value["changes"]["stability"]["multiplier"], "1.5x");
+    }
+
+    // === DEMOTE TESTS ===
+
+    #[tokio::test]
+    async fn test_demote_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute_demote(&storage, &test_cognitive(), None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_demote_invalid_uuid_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "id": "bad-id" });
+        let result = execute_demote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid node ID format"));
+    }
+
+    #[tokio::test]
+    async fn test_demote_nonexistent_node_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args =
+            serde_json::json!({ "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute_demote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Node not found"));
+    }
+
+    #[tokio::test]
+    async fn test_demote_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "id": id, "reason": "It was wrong" });
+        let result = execute_demote(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["success"], true);
+        assert_eq!(value["action"], "demoted");
+        assert_eq!(value["nodeId"], id);
+        assert_eq!(value["reason"], "It was wrong");
+        assert!(value["note"].as_str().unwrap().contains("NOT deleted"));
+    }
+
+    #[tokio::test]
+    async fn test_demote_changes_contain_expected_fields() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "id": id });
+        let result = execute_demote(&storage, &test_cognitive(), Some(args)).await;
+        let value = result.unwrap();
+        assert!(value["changes"]["retrievalStrength"]["before"].is_number());
+        assert!(value["changes"]["retrievalStrength"]["after"].is_number());
+        assert_eq!(value["changes"]["retrievalStrength"]["delta"], "-0.30");
+        assert_eq!(value["changes"]["retentionStrength"]["delta"], "-0.15");
+        assert_eq!(value["changes"]["stability"]["multiplier"], "0.5x");
+    }
+
+    // === REQUEST FEEDBACK TESTS ===
+
+    #[tokio::test]
+    async fn test_request_feedback_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute_request_feedback(&storage, None).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_request_feedback_invalid_uuid_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "id": "not-valid" });
+        let result = execute_request_feedback(&storage, Some(args)).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_request_feedback_nonexistent_node_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args =
+            serde_json::json!({ "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute_request_feedback(&storage, Some(args)).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_request_feedback_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_test_memory(&storage).await;
+        let args = serde_json::json!({ "id": id, "context": "debugging" });
+        let result = execute_request_feedback(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "request_feedback");
+        assert_eq!(value["nodeId"], id);
+        assert!(value["memoryPreview"].is_string());
+        assert!(value["options"].is_array());
+        assert_eq!(value["options"].as_array().unwrap().len(), 3);
+        assert_eq!(value["context"], "debugging");
+    }
+
+    #[tokio::test]
+    async fn test_request_feedback_truncates_long_content() {
+        let (storage, _dir) = test_storage().await;
+        let long_content = "A".repeat(200);
+        let mut s = storage.lock().await;
+        let node = s
+            .ingest(vestige_core::IngestInput {
+                content: long_content,
+                node_type: "fact".to_string(),
+                source: None,
+                sentiment_score: 0.0,
+                sentiment_magnitude: 0.0,
+                tags: vec![],
+                valid_from: None,
+                valid_until: None,
+            })
+            .unwrap();
+        drop(s);
+
+        let args = serde_json::json!({ "id": node.id });
+        let result = execute_request_feedback(&storage, Some(args)).await;
+        let value = result.unwrap();
+        let preview = value["memoryPreview"].as_str().unwrap();
+        assert!(preview.ends_with("..."));
+        assert!(preview.len() <= 103);
+    }
+}

crates/vestige-mcp/src/tools/importance.rs

@@ -3,13 +3,17 @@
 //! Exposes the 4-channel importance signaling system as an MCP tool.
 //! Wraps ImportanceSignals::compute_importance() from vestige-core's
 //! neuroscience module (dopamine/norepinephrine/acetylcholine/serotonin model).
+//!
+//! v1.5.0: Uses CognitiveEngine's persistent signals so novelty/reward/attention
+//! accumulate across calls (not freshly created per call).
 
 use serde::Deserialize;
 use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use vestige_core::{ImportanceContext, ImportanceSignals, Storage};
+use crate::cognitive::CognitiveEngine;
+use vestige_core::{ImportanceContext, Storage};
 
 /// Input schema for importance_score tool
 pub fn schema() -> Value {
@@ -44,6 +48,7 @@ struct ImportanceArgs {
 
 pub async fn execute(
     _storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: ImportanceArgs = match args {
@@ -55,8 +60,6 @@ pub async fn execute(
         return Err("Content cannot be empty".to_string());
     }
 
-    let signals = ImportanceSignals::new();
-
     let mut context = ImportanceContext::current();
     if let Some(project) = args.project {
         context = context.with_project(project);
@@ -65,7 +68,24 @@ pub async fn execute(
         context = context.with_tags(topics);
     }
 
-    let score = signals.compute_importance(&args.content, &context);
+    // Use CognitiveEngine's persistent signals (novelty/reward/attention accumulate)
+    let cog = cognitive.lock().await;
+    let score = cog.importance_signals.compute_importance(&args.content, &context);
+
+    // Also detect emotional markers for richer output
+    let emotional_markers = cog.arousal_signal.detect_emotional_markers(&args.content);
+    drop(cog);
+
+    let markers_json: Vec<Value> = emotional_markers
+        .iter()
+        .map(|m| {
+            serde_json::json!({
+                "type": format!("{:?}", m.marker_type),
+                "text": m.text,
+                "intensity": m.intensity
+            })
+        })
+        .collect();
 
     Ok(serde_json::json!({
         "composite": score.composite,
@@ -89,6 +109,7 @@ pub async fn execute(
             "reward": score.reward_explanation.as_ref().map(|e| format!("{:?}", e)),
             "attention": score.attention_explanation.as_ref().map(|e| format!("{:?}", e))
         },
+        "emotionalMarkers": markers_json,
         "summary": score.summary(),
         "dominantSignal": score.dominant_signal()
     }))
@@ -97,6 +118,11 @@ pub async fn execute(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cognitive::CognitiveEngine;
+
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
 
     #[test]
     fn test_schema_has_required_fields() {
@@ -114,7 +140,7 @@ mod tests {
         let storage = Arc::new(Mutex::new(
             Storage::new(Some(std::path::PathBuf::from("/tmp/test_importance.db"))).unwrap(),
         ));
-        let result = execute(&storage, Some(serde_json::json!({ "content": "" }))).await;
+        let result = execute(&storage, &test_cognitive(), Some(serde_json::json!({ "content": "" }))).await;
         assert!(result.is_err());
     }
 
@@ -125,6 +151,7 @@ mod tests {
         ));
         let result = execute(
             &storage,
+            &test_cognitive(),
             Some(serde_json::json!({
                 "content": "CRITICAL: Production database migration failed with data loss!"
             })),

crates/vestige-mcp/src/tools/ingest.rs

@@ -1,13 +1,21 @@
 //! Ingest Tool
 //!
 //! Add new knowledge to memory.
+//!
+//! v1.5.0: Enhanced with same cognitive pipeline as smart_ingest:
+//!   Pre-ingest: importance scoring + intent detection
+//!   Post-ingest: synaptic tagging + novelty model update + hippocampal indexing
 
+use chrono::Utc;
 use serde::Deserialize;
 use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use vestige_core::{IngestInput, Storage};
+use crate::cognitive::CognitiveEngine;
+use vestige_core::{
+    ContentType, ImportanceContext, ImportanceEvent, ImportanceEventType, IngestInput, Storage,
+};
 
 /// Input schema for ingest tool
 pub fn schema() -> Value {
@@ -48,6 +56,7 @@ struct IngestArgs {
 
 pub async fn execute(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: IngestArgs = match args {
@@ -64,45 +73,103 @@ pub async fn execute(
         return Err("Content too large (max 1MB)".to_string());
     }
 
+    // ====================================================================
+    // COGNITIVE PRE-INGEST: importance scoring + intent detection
+    // ====================================================================
+    let mut importance_composite = 0.0_f64;
+    let mut tags = args.tags.unwrap_or_default();
+    let mut is_novel = false;
+    let mut embedding_strategy = String::new();
+
+    if let Ok(cog) = cognitive.try_lock() {
+        // Full 4-channel importance scoring
+        let context = ImportanceContext::current();
+        let importance = cog.importance_signals.compute_importance(&args.content, &context);
+        importance_composite = importance.composite;
+
+        // Standalone novelty check (dopaminergic signal)
+        let novelty_ctx = vestige_core::neuroscience::importance_signals::Context::default();
+        is_novel = cog.novelty_signal.is_novel(&args.content, &novelty_ctx);
+
+        // Intent detection → auto-tag
+        let intent_result = cog.intent_detector.detect_intent();
+        if intent_result.confidence > 0.5 {
+            let intent_tag = format!("intent:{:?}", intent_result.primary_intent);
+            let intent_tag = if intent_tag.len() > 50 {
+                format!("{}...", &intent_tag[..47])
+            } else {
+                intent_tag
+            };
+            tags.push(intent_tag);
+        }
+
+        // Detect content type → select adaptive embedding strategy
+        let content_type = ContentType::detect(&args.content);
+        let strategy = cog.adaptive_embedder.select_strategy(&content_type);
+        embedding_strategy = format!("{:?}", strategy);
+    }
+
     let input = IngestInput {
-        content: args.content,
+        content: args.content.clone(),
         node_type: args.node_type.unwrap_or_else(|| "fact".to_string()),
         source: args.source,
         sentiment_score: 0.0,
-        sentiment_magnitude: 0.0,
-        tags: args.tags.unwrap_or_default(),
+        sentiment_magnitude: importance_composite,
+        tags,
         valid_from: None,
         valid_until: None,
     };
 
-    let mut storage = storage.lock().await;
+    // ====================================================================
+    // INGEST (storage lock)
+    // ====================================================================
+    let mut storage_guard = storage.lock().await;
 
     // Route through smart_ingest when embeddings are available to prevent duplicates.
     // Falls back to raw ingest only when embeddings aren't ready.
     #[cfg(all(feature = "embeddings", feature = "vector-search"))]
     {
         let fallback_input = input.clone();
-        match storage.smart_ingest(input) {
+        match storage_guard.smart_ingest(input) {
             Ok(result) => {
+                let node_id = result.node.id.clone();
+                let node_content = result.node.content.clone();
+                let node_type = result.node.node_type.clone();
+                let has_embedding = result.node.has_embedding.unwrap_or(false);
+                drop(storage_guard);
+
+                run_post_ingest(cognitive, &node_id, &node_content, &node_type, importance_composite);
+
                 return Ok(serde_json::json!({
                     "success": true,
-                    "nodeId": result.node.id,
+                    "nodeId": node_id,
                     "decision": result.decision,
-                    "message": format!("Knowledge ingested successfully. Node ID: {} ({})", result.node.id, result.decision),
-                    "hasEmbedding": result.node.has_embedding.unwrap_or(false),
+                    "message": format!("Knowledge ingested successfully. Node ID: {} ({})", node_id, result.decision),
+                    "hasEmbedding": has_embedding,
                     "similarity": result.similarity,
                     "reason": result.reason,
+                    "isNovel": is_novel,
+                    "embeddingStrategy": embedding_strategy,
                 }));
             }
             Err(_) => {
-                // smart_ingest failed — fall through to raw ingest with cloned input
-                let node = storage.ingest(fallback_input).map_err(|e| e.to_string())?;
+                let node = storage_guard.ingest(fallback_input).map_err(|e| e.to_string())?;
+                let node_id = node.id.clone();
+                let node_content = node.content.clone();
+                let node_type = node.node_type.clone();
+                let has_embedding = node.has_embedding.unwrap_or(false);
+                drop(storage_guard);
+
+                run_post_ingest(cognitive, &node_id, &node_content, &node_type, importance_composite);
+
                 return Ok(serde_json::json!({
                     "success": true,
-                    "nodeId": node.id,
+                    "nodeId": node_id,
                     "decision": "create",
-                    "message": format!("Knowledge ingested successfully. Node ID: {}", node.id),
-                    "hasEmbedding": node.has_embedding.unwrap_or(false),
+                    "message": format!("Knowledge ingested successfully. Node ID: {}", node_id),
+                    "hasEmbedding": has_embedding,
+                    "isNovel": is_novel,
+                    "embeddingStrategy": embedding_strategy,
                 }));
             }
         }
@@ -111,17 +178,62 @@ pub async fn execute(
     // Fallback for builds without embedding features
     #[cfg(not(all(feature = "embeddings", feature = "vector-search")))]
     {
-        let node = storage.ingest(input).map_err(|e| e.to_string())?;
+        let node = storage_guard.ingest(input).map_err(|e| e.to_string())?;
+        let node_id = node.id.clone();
+        let node_content = node.content.clone();
+        let node_type = node.node_type.clone();
+        let has_embedding = node.has_embedding.unwrap_or(false);
+        drop(storage_guard);
+
+        run_post_ingest(cognitive, &node_id, &node_content, &node_type, importance_composite);
+
         Ok(serde_json::json!({
             "success": true,
-            "nodeId": node.id,
+            "nodeId": node_id,
             "decision": "create",
-            "message": format!("Knowledge ingested successfully. Node ID: {}", node.id),
-            "hasEmbedding": node.has_embedding.unwrap_or(false),
+            "message": format!("Knowledge ingested successfully. Node ID: {}", node_id),
+            "hasEmbedding": has_embedding,
+            "isNovel": is_novel,
+            "embeddingStrategy": embedding_strategy,
         }))
     }
 }
 
+/// Cognitive post-ingest side effects: synaptic tagging, novelty update, hippocampal indexing.
+fn run_post_ingest(
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
+    node_id: &str,
+    content: &str,
+    node_type: &str,
+    importance_composite: f64,
+) {
+    if let Ok(mut cog) = cognitive.try_lock() {
+        // Synaptic tagging for retroactive capture
+        if importance_composite > 0.3 {
+            cog.synaptic_tagging.tag_memory(node_id);
+            if importance_composite > 0.7 {
+                let event = ImportanceEvent::for_memory(node_id, ImportanceEventType::NoveltySpike);
+                let _capture = cog.synaptic_tagging.trigger_prp(event);
+            }
+        }
+
+        // Update novelty model
+        cog.importance_signals.learn_content(content);
+
+        // Record in hippocampal index
+        let _ = cog.hippocampal_index.index_memory(
+            node_id,
+            content,
+            node_type,
+            Utc::now(),
+            None,
+        );
+
+        // Cross-project pattern recording
+        cog.cross_project.record_project_memory(node_id, "default", None);
+    }
+}
+
 // ============================================================================
 // TESTS
 // ============================================================================
@@ -129,8 +241,13 @@ pub async fn execute(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cognitive::CognitiveEngine;
     use tempfile::TempDir;
 
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
     /// Create a test storage instance with a temporary database
     async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
         let dir = TempDir::new().unwrap();
@@ -146,7 +263,7 @@ mod tests {
     async fn test_ingest_empty_content_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "content": "" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("empty"));
     }
@@ -155,7 +272,7 @@ mod tests {
     async fn test_ingest_whitespace_only_content_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "content": "   \n\t  " });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("empty"));
     }
@@ -163,7 +280,7 @@ mod tests {
     #[tokio::test]
     async fn test_ingest_missing_arguments_fails() {
         let (storage, _dir) = test_storage().await;
-        let result = execute(&storage, None).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Missing arguments"));
     }
@@ -172,7 +289,7 @@ mod tests {
     async fn test_ingest_missing_content_field_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "node_type": "fact" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Invalid arguments"));
     }
@@ -187,7 +304,7 @@ mod tests {
         // Create content larger than 1MB
         let large_content = "x".repeat(1_000_001);
         let args = serde_json::json!({ "content": large_content });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("too large"));
     }
@@ -198,7 +315,7 @@ mod tests {
         // Create content exactly 1MB
         let exact_content = "x".repeat(1_000_000);
         let args = serde_json::json!({ "content": exact_content });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
     }
 
@@ -212,7 +329,7 @@ mod tests {
         let args = serde_json::json!({
             "content": "This is a test fact to remember."
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -228,7 +345,7 @@ mod tests {
             "content": "Error handling should use Result<T, E> pattern.",
             "node_type": "pattern"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -242,7 +359,7 @@ mod tests {
             "content": "The Rust programming language emphasizes safety.",
             "tags": ["rust", "programming", "safety"]
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -256,7 +373,7 @@ mod tests {
             "content": "MCP protocol version 2024-11-05 is the current standard.",
             "source": "https://modelcontextprotocol.io/spec"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -272,7 +389,7 @@ mod tests {
             "tags": ["architecture", "design"],
             "source": "team meeting notes"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -290,7 +407,7 @@ mod tests {
         let args = serde_json::json!({
             "content": "Default type test content."
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         // Verify node was created - the default type is "fact"

crates/vestige-mcp/src/tools/intention_unified.rs

@@ -14,7 +14,11 @@ use std::sync::Arc;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 
-use vestige_core::{IntentionRecord, Storage};
+use crate::cognitive::CognitiveEngine;
+use vestige_core::IntentionRecord;
+use vestige_core::Storage;
+use vestige_core::neuroscience::ProspectiveContext;
+use vestige_core::neuroscience::prospective_memory::IntentionTrigger as ProspectiveTrigger;
 
 /// Unified schema for the `intention` tool
 pub fn schema() -> Value {
@@ -196,6 +200,7 @@ struct UnifiedIntentionArgs {
 /// Execute the unified intention tool
 pub async fn execute(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: UnifiedIntentionArgs = match args {
@@ -204,8 +209,8 @@ pub async fn execute(
     };
 
     match args.action.as_str() {
-        "set" => execute_set(storage, &args).await,
-        "check" => execute_check(storage, &args).await,
+        "set" => execute_set(storage, cognitive, &args).await,
+        "check" => execute_check(storage, cognitive, &args).await,
         "update" => execute_update(storage, &args).await,
         "list" => execute_list(storage, &args).await,
         _ => Err(format!(
@@ -222,6 +227,7 @@ pub async fn execute(
 /// Execute "set" action - create a new intention
 async fn execute_set(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: &UnifiedIntentionArgs,
 ) -> Result<Value, String> {
     let description = args
@@ -240,7 +246,66 @@ async fn execute_set(
     let now = Utc::now();
     let id = Uuid::new_v4().to_string();
 
-    // Determine trigger type and data
+    // ====================================================================
+    // COGNITIVE: NLP parsing + intent auto-tagging
+    // ====================================================================
+    let mut nlp_parsed = false;
+    let mut nlp_trigger_type = None;
+    let mut nlp_trigger_data = None;
+    let mut nlp_priority = None;
+    let mut tags = Vec::new();
+
+    if let Ok(cog) = cognitive.try_lock() {
+        // 8A. Try NLP parsing when no explicit trigger is provided
+        if args.trigger.is_none() {
+            if let Ok(parsed) = cog.intention_parser.parse(description) {
+                nlp_parsed = true;
+                // Extract trigger info from parsed intention
+                let (t_type, t_data) = match &parsed.trigger {
+                    ProspectiveTrigger::TimeBased { .. } => {
+                        ("time".to_string(), serde_json::json!({"type": "time"}).to_string())
+                    }
+                    ProspectiveTrigger::DurationBased { after, .. } => {
+                        let mins = after.num_minutes();
+                        ("time".to_string(), serde_json::json!({"type": "time", "in_minutes": mins}).to_string())
+                    }
+                    ProspectiveTrigger::EventBased { condition, .. } => {
+                        ("event".to_string(), serde_json::json!({"type": "event", "condition": condition}).to_string())
+                    }
+                    ProspectiveTrigger::ContextBased { context_match } => {
+                        ("context".to_string(), serde_json::json!({"type": "context", "topic": format!("{:?}", context_match)}).to_string())
+                    }
+                    ProspectiveTrigger::Recurring { .. } => {
+                        ("recurring".to_string(), serde_json::json!({"type": "recurring"}).to_string())
+                    }
+                    _ => {
+                        ("event".to_string(), serde_json::json!({"type": "event"}).to_string())
+                    }
+                };
+                nlp_trigger_type = Some(t_type);
+                nlp_trigger_data = Some(t_data);
+
+                // Use NLP-detected priority if user didn't specify one
+                if args.priority.is_none() {
+                    nlp_priority = Some(parsed.priority);
+                }
+            }
+        }
+
+        // Auto-tag with detected intent
+        let intent_result = cog.intent_detector.detect_intent();
+        if intent_result.confidence > 0.5 {
+            let intent_tag = format!("intent:{:?}", intent_result.primary_intent);
+            let intent_tag = if intent_tag.len() > 50 {
+                format!("{}...", &intent_tag[..47])
+            } else {
+                intent_tag
+            };
+            tags.push(intent_tag);
+        }
+    }
+
+    // Determine trigger type and data (explicit > NLP > manual)
     let (trigger_type, trigger_data) = if let Some(trigger) = &args.trigger {
         let t_type = trigger
             .trigger_type
@@ -248,16 +313,33 @@ async fn execute_set(
             .unwrap_or_else(|| "time".to_string());
         let data = serde_json::to_string(trigger).unwrap_or_else(|_| "{}".to_string());
         (t_type, data)
+    } else if let (Some(t_type), Some(t_data)) = (nlp_trigger_type, nlp_trigger_data) {
+        (t_type, t_data)
     } else {
         ("manual".to_string(), "{}".to_string())
     };
 
-    // Parse priority
+    // Parse priority (explicit > NLP > normal)
     let priority = match args.priority.as_deref() {
         Some("low") => 1,
         Some("high") => 3,
         Some("critical") => 4,
-        _ => 2, // normal
+        Some("normal") => 2,
+        Some(_) => 2,
+        None => {
+            // Use NLP-detected priority if available
+            if let Some(nlp_p) = nlp_priority {
+                use vestige_core::neuroscience::prospective_memory::Priority;
+                match nlp_p {
+                    Priority::Low => 1,
+                    Priority::Normal => 2,
+                    Priority::High => 3,
+                    Priority::Critical => 4,
+                }
+            } else {
+                2 // normal default
+            }
+        }
     };
 
     // Parse deadline
@@ -295,10 +377,10 @@ async fn execute_set(
         reminder_count: 0,
         last_reminded_at: None,
         notes: None,
-        tags: vec![],
+        tags,
         related_memories: vec![],
         snoozed_until: None,
-        source_type: "mcp".to_string(),
+        source_type: if nlp_parsed { "nlp" } else { "mcp" }.to_string(),
         source_data: None,
     };
 
@@ -313,15 +395,38 @@ async fn execute_set(
         "priority": priority,
         "triggerAt": trigger_at.map(|dt| dt.to_rfc3339()),
         "deadline": deadline.map(|dt| dt.to_rfc3339()),
+        "nlpParsed": nlp_parsed,
     }))
 }
 
 /// Execute "check" action - find triggered intentions
 async fn execute_check(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: &UnifiedIntentionArgs,
 ) -> Result<Value, String> {
     let now = Utc::now();
+
+    // ====================================================================
+    // COGNITIVE: Update prospective memory context
+    // ====================================================================
+    if let Some(ctx) = &args.context {
+        if let Ok(cog) = cognitive.try_lock() {
+            let mut prospective_ctx = ProspectiveContext::new();
+            if let Some(codebase) = &ctx.codebase {
+                prospective_ctx.project_name = Some(codebase.clone());
+            }
+            if let Some(file) = &ctx.file {
+                prospective_ctx.active_files = vec![file.clone()];
+            }
+            if let Some(topics) = &ctx.topics {
+                prospective_ctx.active_topics = topics.clone();
+            }
+            // Update context on prospective memory (triggers internal monitoring)
+            let _ = cog.prospective_memory.update_context(prospective_ctx);
+        }
+    }
+
     let storage = storage.lock().await;
 
     // Get active intentions
@@ -571,8 +676,13 @@ async fn execute_list(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cognitive::CognitiveEngine;
     use tempfile::TempDir;
 
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
     /// Create a test storage instance with a temporary database
     async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
         let dir = TempDir::new().unwrap();
@@ -586,7 +696,7 @@ mod tests {
             "action": "set",
             "description": description
         });
-        let result = execute(storage, Some(args)).await.unwrap();
+        let result = execute(storage, &test_cognitive(), Some(args)).await.unwrap();
         result["intentionId"].as_str().unwrap().to_string()
     }
 
@@ -598,7 +708,7 @@ mod tests {
     async fn test_missing_action_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({});
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Invalid arguments"));
     }
@@ -607,7 +717,7 @@ mod tests {
     async fn test_unknown_action_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "action": "unknown" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Unknown action"));
     }
@@ -615,7 +725,7 @@ mod tests {
     #[tokio::test]
     async fn test_missing_arguments_fails() {
         let (storage, _dir) = test_storage().await;
-        let result = execute(&storage, None).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Missing arguments"));
     }
@@ -631,7 +741,7 @@ mod tests {
             "action": "set",
             "description": "Remember to write unit tests"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -648,7 +758,7 @@ mod tests {
     async fn test_set_action_missing_description_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "action": "set" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Missing 'description'"));
     }
@@ -660,7 +770,7 @@ mod tests {
             "action": "set",
             "description": ""
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("empty"));
     }
@@ -673,7 +783,7 @@ mod tests {
             "description": "Critical bug fix needed",
             "priority": "critical"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -692,7 +802,7 @@ mod tests {
                 "at": future_time
             }
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -710,7 +820,7 @@ mod tests {
                 "inMinutes": 30
             }
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -726,7 +836,7 @@ mod tests {
             "description": "Complete feature by end of week",
             "deadline": deadline
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -741,7 +851,7 @@ mod tests {
     async fn test_check_action_empty_succeeds() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "action": "check" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -757,7 +867,7 @@ mod tests {
         create_test_intention(&storage, "Future task").await;
 
         let args = serde_json::json!({ "action": "check" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -778,7 +888,7 @@ mod tests {
                 "codebase": "payments"
             }
         });
-        execute(&storage, Some(set_args)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(set_args)).await.unwrap();
 
         // Check with matching context
         let check_args = serde_json::json!({
@@ -787,7 +897,7 @@ mod tests {
                 "codebase": "payments-service"
             }
         });
-        let result = execute(&storage, Some(check_args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(check_args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -809,10 +919,10 @@ mod tests {
                 "at": past_time
             }
         });
-        execute(&storage, Some(set_args)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(set_args)).await.unwrap();
 
         let check_args = serde_json::json!({ "action": "check" });
-        let result = execute(&storage, Some(check_args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(check_args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -834,7 +944,7 @@ mod tests {
             "id": intention_id,
             "status": "complete"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -854,7 +964,7 @@ mod tests {
             "id": fake_id,
             "status": "complete"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("not found"));
     }
@@ -866,7 +976,7 @@ mod tests {
             "action": "update",
             "status": "complete"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Missing 'id'"));
     }
@@ -880,7 +990,7 @@ mod tests {
             "action": "update",
             "id": intention_id
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Missing 'status'"));
     }
@@ -900,7 +1010,7 @@ mod tests {
             "status": "snooze",
             "snooze_minutes": 30
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -920,7 +1030,7 @@ mod tests {
             "id": intention_id,
             "status": "snooze"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -941,7 +1051,7 @@ mod tests {
             "id": intention_id,
             "status": "cancel"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -960,7 +1070,7 @@ mod tests {
             "id": intention_id,
             "status": "invalid"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Unknown status"));
     }
@@ -973,7 +1083,7 @@ mod tests {
     async fn test_list_action_empty_succeeds() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "action": "list" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -990,7 +1100,7 @@ mod tests {
         create_test_intention(&storage, "Second task").await;
 
         let args = serde_json::json!({ "action": "list" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -1008,7 +1118,7 @@ mod tests {
             "id": intention_id,
             "status": "complete"
         });
-        execute(&storage, Some(complete_args)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(complete_args)).await.unwrap();
 
         // Create another active one
         create_test_intention(&storage, "Active task").await;
@@ -1018,7 +1128,7 @@ mod tests {
             "action": "list",
             "filter_status": "fulfilled"
         });
-        let result = execute(&storage, Some(list_args)).await.unwrap();
+        let result = execute(&storage, &test_cognitive(), Some(list_args)).await.unwrap();
         assert_eq!(result["total"], 1);
         assert_eq!(result["status"], "fulfilled");
     }
@@ -1034,7 +1144,7 @@ mod tests {
             "action": "list",
             "limit": 3
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -1054,14 +1164,14 @@ mod tests {
             "id": intention_id,
             "status": "complete"
         });
-        execute(&storage, Some(complete_args)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(complete_args)).await.unwrap();
 
         // List all
         let list_args = serde_json::json!({
             "action": "list",
             "filter_status": "all"
         });
-        let result = execute(&storage, Some(list_args)).await.unwrap();
+        let result = execute(&storage, &test_cognitive(), Some(list_args)).await.unwrap();
         assert_eq!(result["total"], 2);
     }
 
@@ -1078,7 +1188,7 @@ mod tests {
 
         // 2. Verify it appears in list
         let list_args = serde_json::json!({ "action": "list" });
-        let list_result = execute(&storage, Some(list_args)).await.unwrap();
+        let list_result = execute(&storage, &test_cognitive(), Some(list_args)).await.unwrap();
         assert_eq!(list_result["total"], 1);
 
         // 3. Snooze it
@@ -1088,7 +1198,7 @@ mod tests {
             "status": "snooze",
             "snooze_minutes": 5
         });
-        let snooze_result = execute(&storage, Some(snooze_args)).await;
+        let snooze_result = execute(&storage, &test_cognitive(), Some(snooze_args)).await;
         assert!(snooze_result.is_ok());
 
         // 4. Complete it
@@ -1097,12 +1207,12 @@ mod tests {
             "id": intention_id,
             "status": "complete"
         });
-        let complete_result = execute(&storage, Some(complete_args)).await;
+        let complete_result = execute(&storage, &test_cognitive(), Some(complete_args)).await;
         assert!(complete_result.is_ok());
 
         // 5. Verify it's no longer active
         let final_list_args = serde_json::json!({ "action": "list" });
-        let final_list = execute(&storage, Some(final_list_args)).await.unwrap();
+        let final_list = execute(&storage, &test_cognitive(), Some(final_list_args)).await.unwrap();
         assert_eq!(final_list["total"], 0);
 
         // 6. Verify it's in fulfilled list
@@ -1110,7 +1220,7 @@ mod tests {
             "action": "list",
             "filter_status": "fulfilled"
         });
-        let fulfilled_list = execute(&storage, Some(fulfilled_args)).await.unwrap();
+        let fulfilled_list = execute(&storage, &test_cognitive(), Some(fulfilled_args)).await.unwrap();
         assert_eq!(fulfilled_list["total"], 1);
     }
 
@@ -1124,25 +1234,25 @@ mod tests {
             "description": "Low priority task",
             "priority": "low"
         });
-        execute(&storage, Some(args_low)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(args_low)).await.unwrap();
 
         let args_critical = serde_json::json!({
             "action": "set",
             "description": "Critical task",
             "priority": "critical"
         });
-        execute(&storage, Some(args_critical)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(args_critical)).await.unwrap();
 
         let args_normal = serde_json::json!({
             "action": "set",
             "description": "Normal task",
             "priority": "normal"
         });
-        execute(&storage, Some(args_normal)).await.unwrap();
+        execute(&storage, &test_cognitive(), Some(args_normal)).await.unwrap();
 
         // List and verify ordering (critical should be first due to priority DESC ordering)
         let list_args = serde_json::json!({ "action": "list" });
-        let list_result = execute(&storage, Some(list_args)).await.unwrap();
+        let list_result = execute(&storage, &test_cognitive(), Some(list_args)).await.unwrap();
         let intentions = list_result["intentions"].as_array().unwrap();
 
         assert!(intentions.len() >= 3);

crates/vestige-mcp/src/tools/maintenance.rs

@@ -9,7 +9,9 @@ use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use vestige_core::Storage;
+use crate::cognitive::CognitiveEngine;
+use vestige_core::advanced::compression::MemoryForCompression;
+use vestige_core::{FSRSScheduler, MemoryLifecycle, MemoryState, Storage};
 
 // ============================================================================
 // SCHEMAS
@@ -184,6 +186,9 @@ pub async fn execute_consolidate(
         "nodesPruned": result.nodes_pruned,
         "decayApplied": result.decay_applied,
         "embeddingsGenerated": result.embeddings_generated,
+        "duplicatesMerged": result.duplicates_merged,
+        "activationsComputed": result.activations_computed,
+        "w20Optimized": result.w20_optimized,
         "durationMs": result.duration_ms,
     }))
 }
@@ -191,13 +196,14 @@ pub async fn execute_consolidate(
 /// Stats tool
 pub async fn execute_stats(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     _args: Option<Value>,
 ) -> Result<Value, String> {
-    let storage = storage.lock().await;
-    let stats = storage.get_stats().map_err(|e| e.to_string())?;
+    let storage_guard = storage.lock().await;
+    let stats = storage_guard.get_stats().map_err(|e| e.to_string())?;
 
     // Compute state distribution from a sample of nodes
-    let nodes = storage.get_all_nodes(500, 0).map_err(|e| e.to_string())?;
+    let nodes = storage_guard.get_all_nodes(500, 0).map_err(|e| e.to_string())?;
     let total = nodes.len();
     let (active, dormant, silent, unavailable) = if total > 0 {
         let mut a = 0usize;
@@ -229,6 +235,119 @@ pub async fn execute_stats(
         0.0
     };
 
+    // ====================================================================
+    // FSRS Preview: Show optimal intervals for a representative memory
+    // ====================================================================
+    let scheduler = FSRSScheduler::default();
+    let fsrs_preview = if let Some(representative) = nodes.first() {
+        let mut state = scheduler.new_card();
+        state.difficulty = representative.difficulty;
+        state.stability = representative.stability;
+        state.reps = representative.reps;
+        state.lapses = representative.lapses;
+        state.last_review = representative.last_accessed;
+        let elapsed = scheduler.days_since_review(&state.last_review);
+        let preview = scheduler.preview_reviews(&state, elapsed);
+        Some(serde_json::json!({
+            "representativeMemoryId": representative.id,
+            "elapsedDays": format!("{:.1}", elapsed),
+            "intervalIfGood": preview.good.interval,
+            "intervalIfEasy": preview.easy.interval,
+            "intervalIfHard": preview.hard.interval,
+            "currentRetrievability": format!("{:.3}", preview.good.retrievability),
+        }))
+    } else {
+        None
+    };
+
+    // ====================================================================
+    // STATE SERVICE: Proper state transitions via Bjork model
+    // ====================================================================
+    let state_distribution_precise = if let Ok(cog) = cognitive.try_lock() {
+        let mut lifecycles: Vec<MemoryLifecycle> = nodes
+            .iter()
+            .take(100) // Sample 100 for performance
+            .map(|node| {
+                let mut lc = MemoryLifecycle::new();
+                lc.last_access = node.last_accessed;
+                lc.access_count = node.reps as u32;
+                lc.state = if node.retention_strength > 0.7 {
+                    MemoryState::Active
+                } else if node.retention_strength > 0.3 {
+                    MemoryState::Dormant
+                } else if node.retention_strength > 0.1 {
+                    MemoryState::Silent
+                } else {
+                    MemoryState::Unavailable
+                };
+                lc
+            })
+            .collect();
+        let batch_result = cog.state_service.batch_update(&mut lifecycles);
+        Some(serde_json::json!({
+            "totalTransitions": batch_result.total_transitions,
+            "activeToDormant": batch_result.active_to_dormant,
+            "dormantToSilent": batch_result.dormant_to_silent,
+            "suppressionsResolved": batch_result.suppressions_resolved,
+            "sampled": lifecycles.len(),
+        }))
+    } else {
+        None
+    };
+
+    // ====================================================================
+    // COMPRESSOR: Find compressible memory groups
+    // ====================================================================
+    let compressible_groups = if let Ok(cog) = cognitive.try_lock() {
+        let memories_for_compression: Vec<MemoryForCompression> = nodes
+            .iter()
+            .filter(|n| n.retention_strength < 0.5) // Only consider low-retention memories
+            .take(50) // Cap for performance
+            .map(|n| MemoryForCompression {
+                id: n.id.clone(),
+                content: n.content.clone(),
+                tags: n.tags.clone(),
+                created_at: n.created_at,
+                last_accessed: Some(n.last_accessed),
+                embedding: None,
+            })
+            .collect();
+        if !memories_for_compression.is_empty() {
+            let groups = cog.compressor.find_compressible_groups(&memories_for_compression);
+            Some(serde_json::json!({
+                "groupCount": groups.len(),
+                "totalCompressible": groups.iter().map(|g| g.len()).sum::<usize>(),
+            }))
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    // ====================================================================
+    // COGNITIVE: Module health summary
+    // ====================================================================
+    let cognitive_health = if let Ok(cog) = cognitive.try_lock() {
+        let activation_count = cog.activation_network.get_associations("_probe_").len();
+        let prediction_accuracy = cog.predictive_memory.prediction_accuracy().unwrap_or(0.0);
+        let scheduler_stats = cog.consolidation_scheduler.get_activity_stats();
+        Some(serde_json::json!({
+            "activationNetworkSize": activation_count,
+            "predictionAccuracy": format!("{:.2}", prediction_accuracy),
+            "modulesActive": 28,
+            "schedulerStats": {
+                "totalEvents": scheduler_stats.total_events,
+                "eventsPerMinute": scheduler_stats.events_per_minute,
+                "isIdle": scheduler_stats.is_idle,
+                "timeUntilNextConsolidation": format!("{:?}", cog.consolidation_scheduler.time_until_next()),
+            },
+        }))
+    } else {
+        None
+    };
+    drop(storage_guard);
+
     Ok(serde_json::json!({
         "tool": "stats",
         "totalMemories": stats.total_nodes,
@@ -248,6 +367,10 @@ pub async fn execute_stats(
             "unavailable": unavailable,
             "sampled": total,
         },
+        "fsrsPreview": fsrs_preview,
+        "cognitiveHealth": cognitive_health,
+        "stateTransitions": state_distribution_precise,
+        "compressibleMemories": compressible_groups,
     }))
 }
 

crates/vestige-mcp/src/tools/memory_unified.rs

@@ -220,4 +220,163 @@ mod tests {
         assert!(schema["properties"]["id"].is_object());
         assert_eq!(schema["required"], serde_json::json!(["action", "id"]));
     }
+
+    // === INTEGRATION TESTS ===
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, tempfile::TempDir) {
+        let dir = tempfile::TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    async fn ingest_memory(storage: &Arc<Mutex<Storage>>) -> String {
+        let mut s = storage.lock().await;
+        let node = s
+            .ingest(vestige_core::IngestInput {
+                content: "Memory unified test content".to_string(),
+                node_type: "fact".to_string(),
+                source: Some("test".to_string()),
+                sentiment_score: 0.0,
+                sentiment_magnitude: 0.0,
+                tags: vec!["test-tag".to_string()],
+                valid_from: None,
+                valid_until: None,
+            })
+            .unwrap();
+        node.id
+    }
+
+    #[tokio::test]
+    async fn test_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_invalid_action_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "invalid", "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid action"));
+    }
+
+    #[tokio::test]
+    async fn test_invalid_uuid_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "get", "id": "not-a-uuid" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid memory ID format"));
+    }
+
+    #[tokio::test]
+    async fn test_get_existing_memory() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_memory(&storage).await;
+        let args = serde_json::json!({ "action": "get", "id": id });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "get");
+        assert_eq!(value["found"], true);
+        assert_eq!(value["node"]["id"], id);
+        assert_eq!(value["node"]["content"], "Memory unified test content");
+        assert_eq!(value["node"]["nodeType"], "fact");
+        assert!(value["node"]["createdAt"].is_string());
+        assert!(value["node"]["tags"].is_array());
+    }
+
+    #[tokio::test]
+    async fn test_get_nonexistent_memory() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "get", "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["found"], false);
+        assert_eq!(value["message"], "Memory not found");
+    }
+
+    #[tokio::test]
+    async fn test_delete_existing_memory() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_memory(&storage).await;
+        let args = serde_json::json!({ "action": "delete", "id": id });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "delete");
+        assert_eq!(value["success"], true);
+    }
+
+    #[tokio::test]
+    async fn test_delete_nonexistent_memory() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "delete", "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["success"], false);
+        assert!(value["message"].as_str().unwrap().contains("not found"));
+    }
+
+    #[tokio::test]
+    async fn test_delete_then_get_returns_not_found() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_memory(&storage).await;
+        let del_args = serde_json::json!({ "action": "delete", "id": id });
+        execute(&storage, Some(del_args)).await.unwrap();
+        let get_args = serde_json::json!({ "action": "get", "id": id });
+        let result = execute(&storage, Some(get_args)).await;
+        let value = result.unwrap();
+        assert_eq!(value["found"], false);
+    }
+
+    #[tokio::test]
+    async fn test_state_existing_memory() {
+        let (storage, _dir) = test_storage().await;
+        let id = ingest_memory(&storage).await;
+        let args = serde_json::json!({ "action": "state", "id": id });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["action"], "state");
+        assert_eq!(value["memoryId"], id);
+        assert!(value["accessibility"].is_number());
+        assert!(value["state"].is_string());
+        assert!(value["description"].is_string());
+        assert!(value["components"]["retentionStrength"].is_number());
+        assert!(value["components"]["retrievalStrength"].is_number());
+        assert!(value["components"]["storageStrength"].is_number());
+        assert_eq!(value["thresholds"]["active"], 0.7);
+        assert_eq!(value["thresholds"]["dormant"], 0.4);
+        assert_eq!(value["thresholds"]["silent"], 0.1);
+    }
+
+    #[tokio::test]
+    async fn test_state_nonexistent_memory_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "action": "state", "id": "00000000-0000-0000-0000-000000000000" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("not found"));
+    }
+
+    #[test]
+    fn test_accessibility_boundary_active() {
+        // Exactly at active threshold
+        let a = compute_accessibility(1.0, 0.7, 0.5);
+        assert!(a >= ACCESSIBILITY_ACTIVE);
+        assert!(matches!(state_from_accessibility(a), MemoryState::Active));
+    }
+
+    #[test]
+    fn test_accessibility_boundary_zero() {
+        let a = compute_accessibility(0.0, 0.0, 0.0);
+        assert_eq!(a, 0.0);
+        assert!(matches!(state_from_accessibility(a), MemoryState::Unavailable));
+    }
 }

crates/vestige-mcp/src/tools/mod.rs

@@ -26,6 +26,12 @@ pub mod checkpoint;
 pub mod dedup;
 pub mod importance;
 
+// v1.5: Cognitive tools
+pub mod dream;
+pub mod explore;
+pub mod predict;
+pub mod restore;
+
 // Deprecated tools - kept for internal backwards compatibility
 // These modules are intentionally unused in the public API
 #[allow(dead_code)]

crates/vestige-mcp/src/tools/predict.rs

@@ -0,0 +1,205 @@
+//! Predict tool — Proactive memory prediction ("what will you need next?").
+//! v1.5.0: Wires PredictiveMemory + SpeculativeRetriever.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use crate::cognitive::CognitiveEngine;
+use vestige_core::Storage;
+
+pub fn schema() -> serde_json::Value {
+    serde_json::json!({
+        "type": "object",
+        "properties": {
+            "context": {
+                "type": "object",
+                "description": "Current context for prediction",
+                "properties": {
+                    "current_file": { "type": "string" },
+                    "current_topics": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "codebase": { "type": "string" }
+                }
+            }
+        }
+    })
+}
+
+pub async fn execute(
+    _storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
+    args: Option<serde_json::Value>,
+) -> Result<serde_json::Value, String> {
+    let context = args.as_ref().and_then(|a| a.get("context"));
+
+    let cog = cognitive.lock().await;
+
+    // Build session context for predictive memory
+    let session_ctx = vestige_core::neuroscience::predictive_retrieval::SessionContext {
+        started_at: chrono::Utc::now(),
+        current_focus: context
+            .and_then(|c| c.get("current_topics"))
+            .and_then(|v| v.as_array())
+            .and_then(|arr| arr.first())
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string()),
+        active_files: context
+            .and_then(|c| c.get("current_file"))
+            .and_then(|v| v.as_str())
+            .map(|s| vec![s.to_string()])
+            .unwrap_or_default(),
+        accessed_memories: Vec::new(),
+        recent_queries: Vec::new(),
+        detected_intent: None,
+        project_context: context
+            .and_then(|c| c.get("codebase"))
+            .and_then(|v| v.as_str())
+            .map(|name| vestige_core::neuroscience::predictive_retrieval::ProjectContext {
+                name: name.to_string(),
+                path: String::new(),
+                technologies: Vec::new(),
+                primary_language: None,
+            }),
+    };
+
+    // Get predictions from predictive memory
+    let predictions = cog.predictive_memory.predict_needed_memories(&session_ctx)
+        .unwrap_or_default();
+    let suggestions = cog.predictive_memory.get_proactive_suggestions(0.3)
+        .unwrap_or_default();
+    let top_interests = cog.predictive_memory.get_top_interests(10)
+        .unwrap_or_default();
+    let accuracy = cog.predictive_memory.prediction_accuracy()
+        .unwrap_or(0.0);
+
+    // Build speculative context
+    let speculative_context = vestige_core::PredictionContext {
+        open_files: context
+            .and_then(|c| c.get("current_file"))
+            .and_then(|v| v.as_str())
+            .map(|s| vec![PathBuf::from(s)])
+            .unwrap_or_default(),
+        recent_edits: Vec::new(),
+        recent_queries: Vec::new(),
+        recent_memory_ids: Vec::new(),
+        project_path: context
+            .and_then(|c| c.get("codebase"))
+            .and_then(|v| v.as_str())
+            .map(PathBuf::from),
+        timestamp: Some(chrono::Utc::now()),
+    };
+    let speculative = cog.speculative_retriever.predict_needed(&speculative_context);
+
+    Ok(serde_json::json!({
+        "predictions": predictions.iter().map(|p| serde_json::json!({
+            "memory_id": p.memory_id,
+            "content_preview": p.content_preview,
+            "confidence": p.confidence,
+            "reasoning": format!("{:?}", p.reasoning),
+        })).collect::<Vec<_>>(),
+        "suggestions": suggestions.iter().map(|p| serde_json::json!({
+            "memory_id": p.memory_id,
+            "content_preview": p.content_preview,
+            "confidence": p.confidence,
+            "reasoning": format!("{:?}", p.reasoning),
+        })).collect::<Vec<_>>(),
+        "speculative": speculative.iter().map(|p| serde_json::json!({
+            "memory_id": p.memory_id,
+            "content_preview": p.content_preview,
+            "confidence": p.confidence,
+            "trigger": format!("{:?}", p.trigger),
+        })).collect::<Vec<_>>(),
+        "top_interests": top_interests,
+        "prediction_accuracy": accuracy,
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cognitive::CognitiveEngine;
+    use tempfile::TempDir;
+
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    #[test]
+    fn test_schema_has_properties() {
+        let s = schema();
+        assert_eq!(s["type"], "object");
+        assert!(s["properties"]["context"].is_object());
+        assert!(s["properties"]["context"]["properties"]["current_file"].is_object());
+        assert!(s["properties"]["context"]["properties"]["current_topics"].is_object());
+        assert!(s["properties"]["context"]["properties"]["codebase"].is_object());
+    }
+
+    #[tokio::test]
+    async fn test_predict_no_args_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert!(value["predictions"].is_array());
+        assert!(value["suggestions"].is_array());
+        assert!(value["speculative"].is_array());
+        assert!(value["prediction_accuracy"].is_number());
+    }
+
+    #[tokio::test]
+    async fn test_predict_empty_context() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "context": {} });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert!(value["predictions"].is_array());
+    }
+
+    #[tokio::test]
+    async fn test_predict_with_full_context() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "context": {
+                "current_file": "/src/main.rs",
+                "current_topics": ["rust", "memory"],
+                "codebase": "vestige"
+            }
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert!(value["predictions"].is_array());
+        assert!(value["top_interests"].is_array());
+    }
+
+    #[tokio::test]
+    async fn test_predict_with_topics_only() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "context": {
+                "current_topics": ["debugging", "errors"]
+            }
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_predict_accuracy_is_number() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        let value = result.unwrap();
+        let accuracy = value["prediction_accuracy"].as_f64().unwrap();
+        assert!(accuracy >= 0.0);
+    }
+}

crates/vestige-mcp/src/tools/restore.rs

@@ -0,0 +1,274 @@
+//! Restore Tool
+//!
+//! Restores memories from a JSON backup file.
+//! Previously CLI-only (vestige-restore binary), now available as an MCP tool
+//! so Claude Code can trigger restores directly.
+
+use serde::Deserialize;
+use serde_json::Value;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use vestige_core::{IngestInput, Storage};
+
+/// Input schema for restore tool
+pub fn schema() -> Value {
+    serde_json::json!({
+        "type": "object",
+        "properties": {
+            "path": {
+                "type": "string",
+                "description": "Path to the backup JSON file to restore from"
+            }
+        },
+        "required": ["path"]
+    })
+}
+
+#[derive(Debug, Deserialize)]
+struct RestoreArgs {
+    path: String,
+}
+
+#[derive(Deserialize)]
+struct BackupWrapper {
+    #[serde(rename = "type")]
+    _type: String,
+    text: String,
+}
+
+#[derive(Deserialize)]
+struct RecallResult {
+    results: Vec<MemoryBackup>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct MemoryBackup {
+    content: String,
+    node_type: Option<String>,
+    tags: Option<Vec<String>>,
+    source: Option<String>,
+}
+
+pub async fn execute(
+    storage: &Arc<Mutex<Storage>>,
+    args: Option<Value>,
+) -> Result<Value, String> {
+    let args: RestoreArgs = match args {
+        Some(v) => serde_json::from_value(v).map_err(|e| format!("Invalid arguments: {}", e))?,
+        None => return Err("Missing arguments".to_string()),
+    };
+
+    let path = std::path::Path::new(&args.path);
+    if !path.exists() {
+        return Err(format!("Backup file not found: {}", args.path));
+    }
+
+    // Read and parse backup
+    let backup_content =
+        std::fs::read_to_string(path).map_err(|e| format!("Failed to read backup: {}", e))?;
+
+    // Try parsing as wrapped format first (MCP response wrapper),
+    // then fall back to direct RecallResult
+    let memories: Vec<MemoryBackup> =
+        if let Ok(wrapper) = serde_json::from_str::<Vec<BackupWrapper>>(&backup_content) {
+            if let Some(first) = wrapper.first() {
+                let recall: RecallResult = serde_json::from_str(&first.text)
+                    .map_err(|e| format!("Failed to parse backup contents: {}", e))?;
+                recall.results
+            } else {
+                return Err("Empty backup file".to_string());
+            }
+        } else if let Ok(recall) = serde_json::from_str::<RecallResult>(&backup_content) {
+            recall.results
+        } else if let Ok(nodes) = serde_json::from_str::<Vec<MemoryBackup>>(&backup_content) {
+            nodes
+        } else {
+            return Err(
+                "Unrecognized backup format. Expected MCP wrapper, RecallResult, or array of memories."
+                    .to_string(),
+            );
+        };
+
+    let total = memories.len();
+    if total == 0 {
+        return Ok(serde_json::json!({
+            "tool": "restore",
+            "success": true,
+            "restored": 0,
+            "total": 0,
+            "message": "No memories found in backup file.",
+        }));
+    }
+
+    let mut storage_guard = storage.lock().await;
+    let mut success_count = 0_usize;
+    let mut error_count = 0_usize;
+
+    for memory in &memories {
+        let input = IngestInput {
+            content: memory.content.clone(),
+            node_type: memory.node_type.clone().unwrap_or_else(|| "fact".to_string()),
+            source: memory.source.clone(),
+            sentiment_score: 0.0,
+            sentiment_magnitude: 0.0,
+            tags: memory.tags.clone().unwrap_or_default(),
+            valid_from: None,
+            valid_until: None,
+        };
+
+        match storage_guard.ingest(input) {
+            Ok(_) => success_count += 1,
+            Err(_) => error_count += 1,
+        }
+    }
+
+    Ok(serde_json::json!({
+        "tool": "restore",
+        "success": true,
+        "restored": success_count,
+        "errors": error_count,
+        "total": total,
+        "message": format!("Restored {}/{} memories from backup.", success_count, total),
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::TempDir;
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    fn write_temp_file(dir: &TempDir, name: &str, content: &str) -> String {
+        let path = dir.path().join(name);
+        let mut f = std::fs::File::create(&path).unwrap();
+        f.write_all(content.as_bytes()).unwrap();
+        path.to_string_lossy().to_string()
+    }
+
+    #[test]
+    fn test_schema_has_required_fields() {
+        let s = schema();
+        assert_eq!(s["type"], "object");
+        assert!(s["properties"]["path"].is_object());
+        assert!(s["required"]
+            .as_array()
+            .unwrap()
+            .contains(&serde_json::json!("path")));
+    }
+
+    #[tokio::test]
+    async fn test_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_missing_path_field_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, Some(serde_json::json!({}))).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_nonexistent_file_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "path": "/tmp/does_not_exist_vestige_test.json" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("not found"));
+    }
+
+    #[tokio::test]
+    async fn test_malformed_json_fails() {
+        let (storage, dir) = test_storage().await;
+        let path = write_temp_file(&dir, "bad.json", "this is not json {{{");
+        let args = serde_json::json!({ "path": path });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Unrecognized backup format"));
+    }
+
+    #[tokio::test]
+    async fn test_restore_direct_array_format() {
+        let (storage, dir) = test_storage().await;
+        let backup = serde_json::json!([
+            { "content": "Memory one", "nodeType": "fact", "tags": ["test"] },
+            { "content": "Memory two", "nodeType": "concept" }
+        ]);
+        let path = write_temp_file(&dir, "backup.json", &backup.to_string());
+        let args = serde_json::json!({ "path": path });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["tool"], "restore");
+        assert_eq!(value["success"], true);
+        assert_eq!(value["restored"], 2);
+        assert_eq!(value["errors"], 0);
+        assert_eq!(value["total"], 2);
+    }
+
+    #[tokio::test]
+    async fn test_restore_recall_result_format() {
+        let (storage, dir) = test_storage().await;
+        let backup = serde_json::json!({
+            "results": [
+                { "content": "Recall memory one" },
+                { "content": "Recall memory two" },
+                { "content": "Recall memory three" }
+            ]
+        });
+        let path = write_temp_file(&dir, "recall.json", &backup.to_string());
+        let args = serde_json::json!({ "path": path });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["restored"], 3);
+        assert_eq!(value["total"], 3);
+    }
+
+    #[tokio::test]
+    async fn test_restore_empty_results_array() {
+        let (storage, dir) = test_storage().await;
+        let backup = serde_json::json!({ "results": [] });
+        let path = write_temp_file(&dir, "empty.json", &backup.to_string());
+        let args = serde_json::json!({ "path": path });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["restored"], 0);
+        assert_eq!(value["total"], 0);
+    }
+
+    #[tokio::test]
+    async fn test_restore_empty_array_returns_error() {
+        // Empty [] parses as Vec<BackupWrapper> first, which has no items → "Empty backup file"
+        let (storage, dir) = test_storage().await;
+        let path = write_temp_file(&dir, "empty_arr.json", "[]");
+        let args = serde_json::json!({ "path": path });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Empty backup file"));
+    }
+
+    #[tokio::test]
+    async fn test_restore_defaults_node_type_to_fact() {
+        let (storage, dir) = test_storage().await;
+        let backup = serde_json::json!([{ "content": "No type specified" }]);
+        let path = write_temp_file(&dir, "notype.json", &backup.to_string());
+        let args = serde_json::json!({ "path": path });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap()["restored"], 1);
+    }
+}

crates/vestige-mcp/src/tools/search_unified.rs

@@ -3,13 +3,27 @@
 //! Merges recall, semantic_search, and hybrid_search into a single `search` tool.
 //! Always uses hybrid search internally (keyword + semantic + RRF fusion).
 //! Implements Testing Effect (Roediger & Karpicke 2006) by auto-strengthening memories on access.
+//!
+//! v1.5.0: Enhanced 7-stage cognitive pipeline:
+//!   1. Reranker (over-fetch 3x, rerank down)
+//!   2. Temporal boosting (recency + validity)
+//!   3. Memory state accessibility filtering
+//!   4. Context matching (topic overlap)
+//!   5. Spreading activation associations
+//!   6. Predictive memory recording
+//!   7. Reconsolidation (mark labile)
 
+use chrono::Utc;
 use serde::Deserialize;
 use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use vestige_core::Storage;
+use crate::cognitive::CognitiveEngine;
+use vestige_core::{
+    CompetitionCandidate, EncodingContext, MemoryLifecycle, MemorySnapshot, MemoryState, Storage,
+    TopicalContext,
+};
 
 /// Input schema for unified search tool
 pub fn schema() -> Value {
@@ -46,6 +60,11 @@ pub fn schema() -> Value {
                 "description": "Level of detail in results. 'brief' = id/type/tags/score only (saves tokens). 'summary' = default 8-field response. 'full' = all fields including FSRS state and timestamps.",
                 "enum": ["brief", "summary", "full"],
                 "default": "summary"
+            },
+            "context_topics": {
+                "type": "array",
+                "items": { "type": "string" },
+                "description": "Optional topics for context-dependent retrieval boosting"
             }
         },
         "required": ["query"]
@@ -61,14 +80,24 @@ struct SearchArgs {
     min_similarity: Option<f32>,
     #[serde(alias = "detail_level")]
     detail_level: Option<String>,
+    context_topics: Option<Vec<String>>,
 }
 
-/// Execute unified search
+/// Execute unified search with 7-stage cognitive pipeline.
 ///
-/// Uses hybrid search (keyword + semantic + RRF fusion) internally.
-/// Auto-strengthens memories on access (Testing Effect - Roediger & Karpicke 2006).
+/// Pipeline:
+///   1. Hybrid search (keyword + semantic + RRF) with 3x over-fetch
+///   2. Reranker (BM25-like rescoring, trim to limit)
+///   3. Temporal boosting (recency + validity windows)
+///   4. Memory state accessibility filtering (Active/Dormant/Silent/Unavailable)
+///   5. Context matching (topic overlap boosting)
+///   6. Spreading activation (find associated memories)
+///   7. Side effects: predictive memory recording + reconsolidation labile marking
+///
+/// Also applies Testing Effect (Roediger & Karpicke 2006) by auto-strengthening on access.
 pub async fn execute(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: SearchArgs = match args {
@@ -102,22 +131,23 @@ pub async fn execute(
     let keyword_weight = 0.5_f32;
     let semantic_weight = 0.5_f32;
 
-    let storage = storage.lock().await;
+    // ====================================================================
+    // STAGE 1: Hybrid search with 3x over-fetch for reranking pool
+    // ====================================================================
+    let overfetch_limit = (limit * 3).min(100); // Cap at 100 to avoid excessive DB load
+    let storage_guard = storage.lock().await;
 
-    // Execute hybrid search
-    let results = storage
-        .hybrid_search(&args.query, limit, keyword_weight, semantic_weight)
+    let results = storage_guard
+        .hybrid_search(&args.query, overfetch_limit, keyword_weight, semantic_weight)
         .map_err(|e| e.to_string())?;
 
-    // Filter results by min_retention and min_similarity
-    let filtered_results: Vec<_> = results
+    // Filter by min_retention and min_similarity first (cheap filters)
+    let mut filtered_results: Vec<_> = results
         .into_iter()
         .filter(|r| {
-            // Check retention strength
             if r.node.retention_strength < min_retention {
                 return false;
             }
-            // Check similarity if semantic score is available
             if let Some(sem_score) = r.semantic_score
                 && sem_score < min_similarity
             {
@@ -127,24 +157,254 @@ pub async fn execute(
         })
         .collect();
 
-    // Auto-strengthen memories on access (Testing Effect - Roediger & Karpicke 2006)
-    // This implements "use it or lose it" - accessed memories get stronger
-    let ids: Vec<&str> = filtered_results.iter().map(|r| r.node.id.as_str()).collect();
-    let _ = storage.strengthen_batch_on_access(&ids); // Ignore errors, don't fail search
+    // ====================================================================
+    // STAGE 2: Reranker (BM25-like rescoring, trim to requested limit)
+    // ====================================================================
+    if let Ok(cog) = cognitive.try_lock() {
+        let candidates: Vec<_> = filtered_results
+            .iter()
+            .map(|r| (r.clone(), r.node.content.clone()))
+            .collect();
 
-    // Format results based on detail_level
+        if let Ok(reranked) = cog.reranker.rerank(&args.query, candidates, Some(limit as usize)) {
+            // Replace filtered_results with reranked items (preserves original SearchResult)
+            filtered_results = reranked.into_iter().map(|rr| rr.item).collect();
+        } else {
+            // Reranker failed — fall back to original order, just truncate
+            filtered_results.truncate(limit as usize);
+        }
+    } else {
+        // Couldn't acquire cognitive lock — truncate to limit
+        filtered_results.truncate(limit as usize);
+    }
+
+    // ====================================================================
+    // STAGE 3: Temporal boosting (recency + validity windows)
+    // ====================================================================
+    if let Ok(cog) = cognitive.try_lock() {
+        for result in &mut filtered_results {
+            let recency = cog.temporal_searcher.recency_boost(result.node.created_at);
+            let validity = cog.temporal_searcher.validity_boost(
+                result.node.valid_from,
+                result.node.valid_until,
+                None,
+            );
+            // Blend: 85% relevance + 15% temporal signal
+            let temporal_factor = recency * validity;
+            result.combined_score =
+                result.combined_score * 0.85 + (result.combined_score * temporal_factor as f32) * 0.15;
+        }
+    }
+
+    // ====================================================================
+    // STAGE 4: Memory state accessibility filtering
+    // ====================================================================
+    if let Ok(cog) = cognitive.try_lock() {
+        for result in &mut filtered_results {
+            // Build a MemoryLifecycle from node data for the calculator
+            let mut lifecycle = MemoryLifecycle::new();
+            lifecycle.last_access = result.node.last_accessed;
+            lifecycle.access_count = result.node.reps as u32;
+            // Determine state from retention strength
+            lifecycle.state = if result.node.retention_strength > 0.7 {
+                MemoryState::Active
+            } else if result.node.retention_strength > 0.3 {
+                MemoryState::Dormant
+            } else if result.node.retention_strength > 0.1 {
+                MemoryState::Silent
+            } else {
+                MemoryState::Unavailable
+            };
+
+            let adjusted = cog
+                .accessibility_calc
+                .calculate(&lifecycle, result.combined_score as f64);
+            result.combined_score = adjusted as f32;
+        }
+    }
+
+    // ====================================================================
+    // STAGE 5: Context matching (Tulving 1973 encoding specificity)
+    // ====================================================================
+    if let Some(ref topics) = args.context_topics {
+        if !topics.is_empty() {
+            let retrieval_ctx = EncodingContext::new()
+                .with_topical(TopicalContext::with_topics(topics.clone()));
+            if let Ok(cog) = cognitive.try_lock() {
+                for result in &mut filtered_results {
+                    // Build encoding context from memory's tags
+                    let encoding_ctx = EncodingContext::new()
+                        .with_topical(TopicalContext::with_topics(result.node.tags.clone()));
+                    let context_score = cog.context_matcher.match_contexts(&encoding_ctx, &retrieval_ctx);
+                    // Blend: context match boosts relevance up to +30%
+                    result.combined_score *= 1.0 + (context_score as f32 * 0.3);
+                }
+            }
+        }
+    }
+
+    // Context reinstatement for top result (helps Claude understand WHY this memory matched)
+    let reinstatement_info: Option<Value> = if let Ok(cog) = cognitive.try_lock() {
+        if let Some(first) = filtered_results.first() {
+            let current_ctx = if let Some(ref topics) = args.context_topics {
+                EncodingContext::new().with_topical(TopicalContext::with_topics(topics.clone()))
+            } else {
+                EncodingContext::new()
+            };
+            let reinstatement = cog.context_matcher.reinstate_context(&first.node.id, &current_ctx);
+            Some(serde_json::json!({
+                "memoryId": reinstatement.memory_id,
+                "temporalHint": reinstatement.temporal_hint,
+                "topicalHint": reinstatement.topical_hint,
+                "sessionHint": reinstatement.session_hint,
+                "relatedMemories": reinstatement.related_memories,
+            }))
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    // ====================================================================
+    // STAGE 5B: Retrieval competition (Anderson et al. 1994)
+    // ====================================================================
+    let mut suppressed_count = 0_usize;
+    if filtered_results.len() > 1 {
+        if let Ok(mut cog) = cognitive.try_lock() {
+            let candidates: Vec<CompetitionCandidate> = filtered_results
+                .iter()
+                .map(|r| CompetitionCandidate {
+                    memory_id: r.node.id.clone(),
+                    relevance_score: r.combined_score as f64,
+                    similarity_to_query: r.semantic_score.unwrap_or(0.0) as f64,
+                })
+                .collect();
+            if let Some(result) = cog.competition_mgr.run_competition(&candidates, 0.7) {
+                // Apply suppression: losers get penalized
+                for suppressed_id in &result.suppressed_ids {
+                    if let Some(r) = filtered_results.iter_mut().find(|r| &r.node.id == suppressed_id) {
+                        r.combined_score *= 0.85; // 15% suppression penalty
+                        suppressed_count += 1;
+                    }
+                }
+            }
+        }
+    }
+
+    // Re-sort by adjusted combined_score (descending) after all score modifications
+    filtered_results.sort_by(|a, b| {
+        b.combined_score
+            .partial_cmp(&a.combined_score)
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    // ====================================================================
+    // STAGE 6: Spreading activation (find associated memories)
+    // ====================================================================
+    let associations: Vec<Value> = if let Ok(mut cog) = cognitive.try_lock() {
+        if let Some(first) = filtered_results.first() {
+            let activated = cog.activation_network.activate(&first.node.id, 1.0);
+            activated
+                .iter()
+                .take(3)
+                .map(|a| {
+                    serde_json::json!({
+                        "memoryId": a.memory_id,
+                        "activation": a.activation,
+                        "distance": a.distance,
+                    })
+                })
+                .collect()
+        } else {
+            vec![]
+        }
+    } else {
+        vec![]
+    };
+
+    // ====================================================================
+    // Auto-strengthen on access (Testing Effect)
+    // ====================================================================
+    let ids: Vec<&str> = filtered_results.iter().map(|r| r.node.id.as_str()).collect();
+    let _ = storage_guard.strengthen_batch_on_access(&ids);
+
+    // Drop storage lock before acquiring cognitive for side effects
+    drop(storage_guard);
+
+    // ====================================================================
+    // STAGE 7: Side effects — predictive memory + reconsolidation
+    // ====================================================================
+    if let Ok(mut cog) = cognitive.try_lock() {
+        // 7A. Record query for predictive memory
+        let _ = cog.predictive_memory.record_query(&args.query, &[]);
+
+        // 7B. Record each accessed memory for predictive/speculative models
+        for result in &filtered_results {
+            let _ = cog.predictive_memory.record_memory_access(
+                &result.node.id,
+                &result.node.content.chars().take(100).collect::<String>(),
+                &result.node.tags,
+            );
+
+            cog.speculative_retriever.record_access(
+                &result.node.id,
+                None,                           // file_context
+                Some(args.query.as_str()),       // query_context
+                None,                            // was_helpful (unknown yet)
+            );
+
+            // 7C. Mark labile for reconsolidation window (5 min)
+            let snapshot = MemorySnapshot {
+                content: result.node.content.clone(),
+                tags: result.node.tags.clone(),
+                retention_strength: result.node.retention_strength,
+                storage_strength: result.node.storage_strength,
+                retrieval_strength: result.node.retrieval_strength,
+                connection_ids: vec![],
+                captured_at: Utc::now(),
+            };
+            cog.reconsolidation.mark_labile(&result.node.id, snapshot);
+        }
+    }
+
+    // ====================================================================
+    // Format and return
+    // ====================================================================
     let formatted: Vec<Value> = filtered_results
         .iter()
         .map(|r| format_search_result(r, detail_level))
         .collect();
 
-    Ok(serde_json::json!({
+    // Check learning mode via attention signal
+    let learning_mode = cognitive.try_lock().ok().map(|cog| cog.attention_signal.is_learning_mode()).unwrap_or(false);
+
+    let mut response = serde_json::json!({
         "query": args.query,
-        "method": "hybrid",
+        "method": "hybrid+cognitive",
         "detailLevel": detail_level,
         "total": formatted.len(),
         "results": formatted,
-    }))
+    });
+
+    // Include associations if any were found
+    if !associations.is_empty() {
+        response["associations"] = serde_json::json!(associations);
+    }
+    // Include context reinstatement if computed
+    if let Some(ri) = reinstatement_info {
+        response["contextReinstatement"] = ri;
+    }
+    // Include competition stats
+    if suppressed_count > 0 {
+        response["competitionSuppressed"] = serde_json::json!(suppressed_count);
+    }
+    // Include learning mode detection
+    if learning_mode {
+        response["learningModeDetected"] = serde_json::json!(true);
+    }
+
+    Ok(response)
 }
 
 /// Format a search result based on the requested detail level.
@@ -247,9 +507,14 @@ pub fn format_node(node: &vestige_core::KnowledgeNode, detail_level: &str) -> Va
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cognitive::CognitiveEngine;
     use tempfile::TempDir;
     use vestige_core::IngestInput;
 
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
     /// Create a test storage instance with a temporary database
     async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
         let dir = TempDir::new().unwrap();
@@ -282,7 +547,7 @@ mod tests {
     async fn test_search_empty_query_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "query": "" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("empty"));
     }
@@ -291,7 +556,7 @@ mod tests {
     async fn test_search_whitespace_only_query_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "query": "   \t\n  " });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("empty"));
     }
@@ -299,7 +564,7 @@ mod tests {
     #[tokio::test]
     async fn test_search_missing_arguments_fails() {
         let (storage, _dir) = test_storage().await;
-        let result = execute(&storage, None).await;
+        let result = execute(&storage, &test_cognitive(), None).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Missing arguments"));
     }
@@ -308,7 +573,7 @@ mod tests {
     async fn test_search_missing_query_field_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "limit": 10 });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Invalid arguments"));
     }
@@ -327,7 +592,7 @@ mod tests {
             "query": "test",
             "limit": 0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
     }
 
@@ -341,7 +606,7 @@ mod tests {
             "query": "test",
             "limit": 1000
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
     }
 
@@ -354,7 +619,7 @@ mod tests {
             "query": "test",
             "limit": -5
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
     }
 
@@ -371,7 +636,7 @@ mod tests {
             "query": "test",
             "min_retention": -0.5
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
     }
 
@@ -384,7 +649,7 @@ mod tests {
             "query": "test",
             "min_retention": 1.5
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         // Should succeed but may return no results (retention > 1.0 clamped to 1.0)
         assert!(result.is_ok());
     }
@@ -402,7 +667,7 @@ mod tests {
             "query": "test",
             "min_similarity": -0.5
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
     }
 
@@ -415,7 +680,7 @@ mod tests {
             "query": "test",
             "min_similarity": 1.5
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         // Should succeed but may return no results
         assert!(result.is_ok());
     }
@@ -430,12 +695,12 @@ mod tests {
         ingest_test_content(&storage, "The Rust programming language is memory safe.").await;
 
         let args = serde_json::json!({ "query": "rust" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
         assert_eq!(value["query"], "rust");
-        assert_eq!(value["method"], "hybrid");
+        assert_eq!(value["method"], "hybrid+cognitive");
         assert!(value["total"].is_number());
         assert!(value["results"].is_array());
     }
@@ -450,7 +715,7 @@ mod tests {
             "query": "python",
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -472,7 +737,7 @@ mod tests {
             "limit": 2,
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -486,7 +751,7 @@ mod tests {
         // Don't ingest anything - database is empty
 
         let args = serde_json::json!({ "query": "anything" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -503,7 +768,7 @@ mod tests {
             "query": "testing",
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -536,7 +801,7 @@ mod tests {
             "query": "item",
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -620,7 +885,7 @@ mod tests {
             "detail_level": "brief",
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -649,7 +914,7 @@ mod tests {
             "detail_level": "full",
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -676,7 +941,7 @@ mod tests {
             "query": "default",
             "min_similarity": 0.0
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -698,7 +963,7 @@ mod tests {
             "query": "test",
             "detail_level": "invalid_level"
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("Invalid detail_level"));
     }

crates/vestige-mcp/src/tools/smart_ingest.rs

@@ -9,13 +9,21 @@
 //! - Updating existing memories when appropriate (low prediction error)
 //! - Creating new memories when content is substantially different (high PE)
 //! - Superseding demoted/outdated memories with better alternatives
+//!
+//! v1.5.0: Enhanced with cognitive pipeline:
+//!   Pre-ingest: importance scoring (4-channel) + intent detection → auto-tag
+//!   Post-ingest: synaptic tagging + novelty model update + hippocampal indexing
 
+use chrono::Utc;
 use serde::Deserialize;
 use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use vestige_core::{IngestInput, Storage};
+use crate::cognitive::CognitiveEngine;
+use vestige_core::{
+    ContentType, ImportanceContext, ImportanceEventType, ImportanceEvent, IngestInput, Storage,
+};
 
 /// Input schema for smart_ingest tool
 pub fn schema() -> Value {
@@ -62,6 +70,7 @@ struct SmartIngestArgs {
 
 pub async fn execute(
     storage: &Arc<Mutex<Storage>>,
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
     args: Option<Value>,
 ) -> Result<Value, String> {
     let args: SmartIngestArgs = match args {
@@ -78,30 +87,72 @@ pub async fn execute(
         return Err("Content too large (max 1MB)".to_string());
     }
 
+    // ====================================================================
+    // COGNITIVE PRE-INGEST: importance scoring + intent detection + content analysis
+    // ====================================================================
+    let mut importance_composite = 0.0_f64;
+    let mut tags = args.tags.unwrap_or_default();
+
+    if let Ok(cog) = cognitive.try_lock() {
+        // 4A. Full 4-channel importance scoring
+        let context = ImportanceContext::current();
+        let importance = cog.importance_signals.compute_importance(&args.content, &context);
+        importance_composite = importance.composite;
+
+        // 4B. Intent detection → auto-tag
+        let intent_result = cog.intent_detector.detect_intent();
+        if intent_result.confidence > 0.5 {
+            let intent_tag = format!("intent:{:?}", intent_result.primary_intent);
+            // Truncate long intent tags
+            let intent_tag = if intent_tag.len() > 50 {
+                format!("{}...", &intent_tag[..47])
+            } else {
+                intent_tag
+            };
+            tags.push(intent_tag);
+        }
+
+        // 4D. Adaptive embedding — detect content type for logging
+        let _content_type = ContentType::detect(&args.content);
+    }
+
     let input = IngestInput {
-        content: args.content,
+        content: args.content.clone(),
         node_type: args.node_type.unwrap_or_else(|| "fact".to_string()),
         source: args.source,
         sentiment_score: 0.0,
-        sentiment_magnitude: 0.0,
-        tags: args.tags.unwrap_or_default(),
+        // Store importance composite as sentiment_magnitude for FSRS encoding boost
+        sentiment_magnitude: importance_composite,
+        tags,
         valid_from: None,
         valid_until: None,
     };
 
-    let mut storage = storage.lock().await;
+    // ====================================================================
+    // INGEST (storage lock)
+    // ====================================================================
+    let mut storage_guard = storage.lock().await;
 
     // Check if force_create is enabled
     if args.force_create.unwrap_or(false) {
-        // Use regular ingest
-        let node = storage.ingest(input).map_err(|e| e.to_string())?;
+        let node = storage_guard.ingest(input).map_err(|e| e.to_string())?;
+        let node_id = node.id.clone();
+        let node_content = node.content.clone();
+        let node_type = node.node_type.clone();
+        let has_embedding = node.has_embedding.unwrap_or(false);
+        drop(storage_guard);
+
+        // Post-ingest cognitive side effects
+        run_post_ingest(cognitive, &node_id, &node_content, &node_type, importance_composite);
+
         return Ok(serde_json::json!({
             "success": true,
             "decision": "create",
-            "nodeId": node.id,
+            "nodeId": node_id,
             "message": "Memory created (force_create=true)",
-            "hasEmbedding": node.has_embedding.unwrap_or(false),
+            "hasEmbedding": has_embedding,
             "predictionError": 1.0,
+            "importanceScore": importance_composite,
             "reason": "Forced creation - skipped similarity check"
         }));
     }
@@ -109,17 +160,26 @@ pub async fn execute(
     // Use smart ingest with prediction error gating
     #[cfg(all(feature = "embeddings", feature = "vector-search"))]
     {
-        let result = storage.smart_ingest(input).map_err(|e| e.to_string())?;
+        let result = storage_guard.smart_ingest(input).map_err(|e| e.to_string())?;
+        let node_id = result.node.id.clone();
+        let node_content = result.node.content.clone();
+        let node_type = result.node.node_type.clone();
+        let has_embedding = result.node.has_embedding.unwrap_or(false);
+        drop(storage_guard);
 
-        Ok(serde_json::json!({
+        // Post-ingest cognitive side effects
+        run_post_ingest(cognitive, &node_id, &node_content, &node_type, importance_composite);
+
+        return Ok(serde_json::json!({
             "success": true,
             "decision": result.decision,
-            "nodeId": result.node.id,
+            "nodeId": node_id,
             "message": format!("Smart ingest complete: {}", result.reason),
-            "hasEmbedding": result.node.has_embedding.unwrap_or(false),
+            "hasEmbedding": has_embedding,
             "similarity": result.similarity,
             "predictionError": result.prediction_error,
             "supersededId": result.superseded_id,
+            "importanceScore": importance_composite,
             "reason": result.reason,
             "explanation": match result.decision.as_str() {
                 "create" => "Created new memory - content was different enough from existing memories",
@@ -131,25 +191,70 @@ pub async fn execute(
                 "add_context" => "Added new content as context to existing memory",
                 _ => "Memory processed successfully"
             }
-        }))
+        }));
     }
 
     #[cfg(not(all(feature = "embeddings", feature = "vector-search")))]
     {
-        // Fall back to regular ingest if features not available
-        let node = storage.ingest(input).map_err(|e| e.to_string())?;
+        let node = storage_guard.ingest(input).map_err(|e| e.to_string())?;
+        let node_id = node.id.clone();
+        let node_content = node.content.clone();
+        let node_type = node.node_type.clone();
+        drop(storage_guard);
+
+        run_post_ingest(cognitive, &node_id, &node_content, &node_type, importance_composite);
+
         Ok(serde_json::json!({
             "success": true,
             "decision": "create",
-            "nodeId": node.id,
+            "nodeId": node_id,
             "message": "Memory created (smart ingest requires embeddings feature)",
             "hasEmbedding": false,
             "predictionError": 1.0,
+            "importanceScore": importance_composite,
             "reason": "Embeddings not available - used regular ingest"
         }))
     }
 }
 
+/// Cognitive post-ingest side effects: synaptic tagging, novelty update, hippocampal indexing.
+///
+/// Uses try_lock() for non-blocking access. If cognitive is locked, side effects are skipped.
+fn run_post_ingest(
+    cognitive: &Arc<Mutex<CognitiveEngine>>,
+    node_id: &str,
+    content: &str,
+    node_type: &str,
+    importance_composite: f64,
+) {
+    if let Ok(mut cog) = cognitive.try_lock() {
+        // 4C. Synaptic tagging for retroactive capture
+        if importance_composite > 0.3 {
+            cog.synaptic_tagging.tag_memory(node_id);
+            if importance_composite > 0.7 {
+                // High importance → trigger PRP for nearby memories
+                let event = ImportanceEvent::for_memory(node_id, ImportanceEventType::NoveltySpike);
+                let _capture = cog.synaptic_tagging.trigger_prp(event);
+            }
+        }
+
+        // 4E. Update novelty model with new content
+        cog.importance_signals.learn_content(content);
+
+        // 4F. Record in hippocampal index
+        let _ = cog.hippocampal_index.index_memory(
+            node_id,
+            content,
+            node_type,
+            Utc::now(),
+            None, // semantic_embedding — generated separately
+        );
+
+        // 4G. Cross-project pattern recording
+        cog.cross_project.record_project_memory(node_id, "default", None);
+    }
+}
+
 // ============================================================================
 // TESTS
 // ============================================================================
@@ -157,8 +262,13 @@ pub async fn execute(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cognitive::CognitiveEngine;
     use tempfile::TempDir;
 
+    fn test_cognitive() -> Arc<Mutex<CognitiveEngine>> {
+        Arc::new(Mutex::new(CognitiveEngine::new()))
+    }
+
     /// Create a test storage instance with a temporary database
     async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
         let dir = TempDir::new().unwrap();
@@ -170,7 +280,7 @@ mod tests {
     async fn test_smart_ingest_empty_content_fails() {
         let (storage, _dir) = test_storage().await;
         let args = serde_json::json!({ "content": "" });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("empty"));
     }
@@ -181,7 +291,7 @@ mod tests {
         let args = serde_json::json!({
             "content": "This is a test fact to remember."
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -197,7 +307,7 @@ mod tests {
             "content": "Force create test content.",
             "forceCreate": true
         });
-        let result = execute(&storage, Some(args)).await;
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
         assert!(result.is_ok());
 
         let value = result.unwrap();
@@ -215,4 +325,83 @@ mod tests {
         assert!(schema_value["properties"]["forceCreate"].is_object());
         assert!(schema_value["required"].as_array().unwrap().contains(&serde_json::json!("content")));
     }
+
+    #[tokio::test]
+    async fn test_smart_ingest_missing_args_fails() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, &test_cognitive(), None).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Missing arguments"));
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_whitespace_only_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "content": "   \t\n  " });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("empty"));
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_too_large_fails() {
+        let (storage, _dir) = test_storage().await;
+        let large = "x".repeat(1_000_001);
+        let args = serde_json::json!({ "content": large });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("too large"));
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_exactly_1mb_succeeds() {
+        let (storage, _dir) = test_storage().await;
+        let content = "x".repeat(1_000_000);
+        let args = serde_json::json!({ "content": content });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_with_node_type() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "content": "A concept to remember",
+            "node_type": "concept"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_with_tags_and_source() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({
+            "content": "Tagged and sourced memory",
+            "tags": ["test", "smart-ingest"],
+            "source": "unit-test"
+        });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["success"], true);
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_response_has_importance_score() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "content": "Important memory content" });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        let value = result.unwrap();
+        assert!(value["importanceScore"].is_number());
+    }
+
+    #[tokio::test]
+    async fn test_smart_ingest_missing_content_field_fails() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "tags": ["test"] });
+        let result = execute(&storage, &test_cognitive(), Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid arguments"));
+    }
 }

crates/vestige-mcp/src/tools/timeline.rs

@@ -58,6 +58,7 @@ pub fn schema() -> Value {
 struct TimelineArgs {
     start: Option<String>,
     end: Option<String>,
+    #[serde(alias = "node_type")]
     node_type: Option<String>,
     tags: Option<Vec<String>>,
     limit: Option<i32>,
@@ -182,3 +183,184 @@ pub async fn execute(
         "timeline": timeline,
     }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    async fn test_storage() -> (Arc<Mutex<Storage>>, TempDir) {
+        let dir = TempDir::new().unwrap();
+        let storage = Storage::new(Some(dir.path().join("test.db"))).unwrap();
+        (Arc::new(Mutex::new(storage)), dir)
+    }
+
+    async fn ingest_test_memory(storage: &Arc<Mutex<Storage>>, content: &str) {
+        let mut s = storage.lock().await;
+        s.ingest(vestige_core::IngestInput {
+            content: content.to_string(),
+            node_type: "fact".to_string(),
+            source: None,
+            sentiment_score: 0.0,
+            sentiment_magnitude: 0.0,
+            tags: vec!["timeline-test".to_string()],
+            valid_from: None,
+            valid_until: None,
+        })
+        .unwrap();
+    }
+
+    #[test]
+    fn test_schema_has_properties() {
+        let s = schema();
+        assert_eq!(s["type"], "object");
+        assert!(s["properties"]["start"].is_object());
+        assert!(s["properties"]["end"].is_object());
+        assert!(s["properties"]["node_type"].is_object());
+        assert!(s["properties"]["tags"].is_object());
+        assert!(s["properties"]["limit"].is_object());
+        assert!(s["properties"]["detail_level"].is_object());
+    }
+
+    #[test]
+    fn test_parse_datetime_rfc3339() {
+        let result = parse_datetime("2026-02-18T10:30:00Z");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_parse_datetime_date_only() {
+        let result = parse_datetime("2026-02-18");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_parse_datetime_invalid() {
+        let result = parse_datetime("not-a-date");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid date/datetime"));
+    }
+
+    #[test]
+    fn test_parse_datetime_empty() {
+        let result = parse_datetime("");
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_timeline_no_args_defaults() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["tool"], "memory_timeline");
+        assert_eq!(value["detailLevel"], "summary");
+        assert!(value["range"]["start"].is_string());
+        assert!(value["range"]["end"].is_string());
+    }
+
+    #[tokio::test]
+    async fn test_timeline_empty_database() {
+        let (storage, _dir) = test_storage().await;
+        let result = execute(&storage, None).await;
+        let value = result.unwrap();
+        assert_eq!(value["totalMemories"], 0);
+        assert_eq!(value["days"], 0);
+        assert!(value["timeline"].as_array().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_timeline_with_memories() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "Timeline test memory 1").await;
+        ingest_test_memory(&storage, "Timeline test memory 2").await;
+        let result = execute(&storage, None).await;
+        let value = result.unwrap();
+        assert_eq!(value["totalMemories"], 2);
+        assert!(value["days"].as_u64().unwrap() >= 1);
+    }
+
+    #[tokio::test]
+    async fn test_timeline_invalid_detail_level() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "detail_level": "invalid" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid detail_level"));
+    }
+
+    #[tokio::test]
+    async fn test_timeline_detail_level_brief() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "Brief test memory").await;
+        let args = serde_json::json!({ "detail_level": "brief" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["detailLevel"], "brief");
+    }
+
+    #[tokio::test]
+    async fn test_timeline_detail_level_full() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "Full test memory").await;
+        let args = serde_json::json!({ "detail_level": "full" });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert_eq!(value["detailLevel"], "full");
+    }
+
+    #[tokio::test]
+    async fn test_timeline_limit_clamped() {
+        let (storage, _dir) = test_storage().await;
+        let args = serde_json::json!({ "limit": 0 });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok()); // limit clamped to 1, no error
+    }
+
+    #[tokio::test]
+    async fn test_timeline_with_date_range() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "Ranged memory").await;
+        let args = serde_json::json!({
+            "start": "2020-01-01",
+            "end": "2030-12-31"
+        });
+        let result = execute(&storage, Some(args)).await;
+        assert!(result.is_ok());
+        let value = result.unwrap();
+        assert!(value["totalMemories"].as_u64().unwrap() >= 1);
+    }
+
+    #[tokio::test]
+    async fn test_timeline_node_type_filter() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "A fact memory").await;
+        let args = serde_json::json!({ "node_type": "concept" });
+        let result = execute(&storage, Some(args)).await;
+        let value = result.unwrap();
+        // Ingested as "fact", filtering for "concept" should yield 0
+        assert_eq!(value["totalMemories"], 0);
+    }
+
+    #[tokio::test]
+    async fn test_timeline_tag_filter() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "Tagged memory").await;
+        let args = serde_json::json!({ "tags": ["timeline-test"] });
+        let result = execute(&storage, Some(args)).await;
+        let value = result.unwrap();
+        assert!(value["totalMemories"].as_u64().unwrap() >= 1);
+    }
+
+    #[tokio::test]
+    async fn test_timeline_tag_filter_no_match() {
+        let (storage, _dir) = test_storage().await;
+        ingest_test_memory(&storage, "Tagged memory").await;
+        let args = serde_json::json!({ "tags": ["nonexistent-tag"] });
+        let result = execute(&storage, Some(args)).await;
+        let value = result.unwrap();
+        assert_eq!(value["totalMemories"], 0);
+    }
+}