chore: estate-wide metadata and submodule sync (2026-04-20)

Author: hyperpolymath

examples/basic_usage.rs

@@ -40,7 +40,9 @@ fn main() {
     let query3 = Query::new("What did we discuss about lifetimes?");
     match orch.process(query3) {
         Ok(response) => {
-            println!("Project: {}", orch.current_project().expect("TODO: handle error"));
+            if let Some(project) = orch.current_project() {
+                println!("Project: {}", project);
+            }
             println!("Response: {}", response.text);
         }
         Err(e) => println!("Error: {}", e),

examples/reservoir_demo.rs

@@ -73,9 +73,13 @@ fn main() {
 
     // Example 4: Reset and Restart
     println!("\n=== Example 4: Reset Reservoir ===");
-    println!("State norm before reset: {:.4}", vector_norm(&cm.reservoir_state().expect("TODO: handle error")));
+    if let Some(state) = cm.reservoir_state() {
+        println!("State norm before reset: {:.4}", vector_norm(&state));
+    }
     cm.reset_reservoir();
-    println!("State norm after reset: {:.4}", vector_norm(&cm.reservoir_state().expect("TODO: handle error")));
+    if let Some(state) = cm.reservoir_state() {
+        println!("State norm after reset: {:.4}", vector_norm(&state));
+    }
 
     println!("\n✅ Reservoir demo completed!");
 }

src/context.rs

@@ -247,7 +247,7 @@ mod tests {
 
         let history = cm.project_history("project-1");
         assert!(history.is_some());
-        assert_eq!(history.expect("TODO: handle error").len(), 1);
+        assert_eq!(history.unwrap().len(), 1);
     }
 
     #[test]
@@ -289,8 +289,8 @@ mod tests {
         let response = create_test_response("test response");
         cm.add_turn(query, response);
 
-        let json = cm.to_json().expect("TODO: handle error");
-        let restored = ContextManager::from_json(&json).expect("TODO: handle error");
+        let json = cm.to_json().unwrap();
+        let restored = ContextManager::from_json(&json).unwrap();
 
         assert_eq!(restored.current_project(), cm.current_project());
         assert_eq!(restored.conversation_count(), cm.conversation_count());
@@ -333,7 +333,7 @@ mod tests {
         // Reservoir state should initially be zeros
         let state1 = cm.reservoir_state();
         assert!(state1.is_some());
-        assert_eq!(state1.as_ref().expect("TODO: handle error").len(), 1000);
+        assert_eq!(state1.as_ref().unwrap().len(), 1000);
 
         // Add a turn - reservoir should update
         cm.add_turn(Query::new("Hello world"), create_test_response("Hi"));
@@ -347,7 +347,7 @@ mod tests {
         // Snapshot should include reservoir state
         let snapshot = cm.snapshot(5);
         assert!(snapshot.reservoir_state.is_some());
-        assert_eq!(snapshot.reservoir_state.expect("TODO: handle error").len(), 1000);
+        assert_eq!(snapshot.reservoir_state.unwrap().len(), 1000);
     }
 
     #[test]
@@ -356,12 +356,12 @@ mod tests {
 
         cm.add_turn(Query::new("test"), create_test_response("response"));
 
-        let state = cm.reservoir_state().expect("TODO: handle error");
+        let state = cm.reservoir_state().unwrap();
         assert!(!state.iter().all(|&x| x == 0.0));
 
         cm.reset_reservoir();
 
-        let state_after_reset = cm.reservoir_state().expect("TODO: handle error");
+        let state_after_reset = cm.reservoir_state().unwrap();
         assert!(state_after_reset.iter().all(|&x| x == 0.0));
     }
 

src/main.rs

@@ -96,7 +96,9 @@ fn run_interactive() {
 
     loop {
         print!("> ");
-        io::stdout().flush().expect("TODO: handle error");
+        // Best-effort flush of the prompt; if stdout is closed the next
+        // read_line() will fail and the loop will exit cleanly.
+        let _ = io::stdout().flush();
 
         let mut input = String::new();
         if io::stdin().read_line(&mut input).is_err() {

src/persistence.rs

@@ -360,14 +360,17 @@ impl ConversationTurn {
     fn from_row(row: &rusqlite::Row) -> Self {
         use crate::types::{Query, Response, RoutingDecision, ResponseMetadata};
 
-        let query_text: String = row.get(0).expect("TODO: handle error");
-        let query_priority: u8 = row.get(1).expect("TODO: handle error");
-        let query_timestamp: u64 = row.get(2).expect("TODO: handle error");
-
-        let response_text: String = row.get(3).expect("TODO: handle error");
-        let response_route_str: String = row.get(4).expect("TODO: handle error");
-        let response_confidence: f32 = row.get(5).expect("TODO: handle error");
-        let latency_ms: i64 = row.get(6).expect("TODO: handle error");
+        // Schema invariant: columns 0-6 are guaranteed present by the
+        // CREATE TABLE statement that produced this row; absence indicates
+        // DB corruption, not a recoverable runtime error.
+        let query_text: String = row.get(0).expect("schema invariant: column 0 (query_text) must exist");
+        let query_priority: u8 = row.get(1).expect("schema invariant: column 1 (query_priority) must exist");
+        let query_timestamp: u64 = row.get(2).expect("schema invariant: column 2 (query_timestamp) must exist");
+
+        let response_text: String = row.get(3).expect("schema invariant: column 3 (response_text) must exist");
+        let response_route_str: String = row.get(4).expect("schema invariant: column 4 (response_route_str) must exist");
+        let response_confidence: f32 = row.get(5).expect("schema invariant: column 5 (response_confidence) must exist");
+        let latency_ms: i64 = row.get(6).expect("schema invariant: column 6 (latency_ms) must exist");
 
         // Parse routing decision
         let route = match response_route_str.as_str() {
@@ -403,7 +406,7 @@ impl ConversationTurn {
 fn current_timestamp() -> u64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
-        .expect("TODO: handle error")
+        .expect("system clock invariant: time is after UNIX_EPOCH (1970-01-01)")
         .as_secs()
 }
 
@@ -429,13 +432,13 @@ mod tests {
 
     #[test]
     fn test_persistence_manager_creation() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
-        assert_eq!(pm.conversation_count(None).expect("TODO: handle error"), 0);
+        let pm = PersistenceManager::new_in_memory().unwrap();
+        assert_eq!(pm.conversation_count(None).unwrap(), 0);
     }
 
     #[test]
     fn test_save_and_load_turn() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
+        let pm = PersistenceManager::new_in_memory().unwrap();
 
         let query = Query::new("What is Rust?");
         let response = Response {
@@ -455,17 +458,17 @@ mod tests {
             response: response.clone(),
         };
 
-        pm.save_turn(None, &turn).expect("TODO: handle error");
+        pm.save_turn(None, &turn).unwrap();
 
-        let history = pm.load_history(None, 10).expect("TODO: handle error");
+        let history = pm.load_history(None, 10).unwrap();
         assert_eq!(history.len(), 1);
         assert_eq!(history[0].query.text, query.text);
         assert_eq!(history[0].response.text, response.text);
     }
 
     #[test]
     fn test_project_isolation() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
+        let pm = PersistenceManager::new_in_memory().unwrap();
 
         let turn1 = ConversationTurn {
             query: Query::new("Project A query"),
@@ -497,11 +500,11 @@ mod tests {
             },
         };
 
-        pm.save_turn(Some("project_a"), &turn1).expect("TODO: handle error");
-        pm.save_turn(Some("project_b"), &turn2).expect("TODO: handle error");
+        pm.save_turn(Some("project_a"), &turn1).unwrap();
+        pm.save_turn(Some("project_b"), &turn2).unwrap();
 
-        let history_a = pm.load_history(Some("project_a"), 10).expect("TODO: handle error");
-        let history_b = pm.load_history(Some("project_b"), 10).expect("TODO: handle error");
+        let history_a = pm.load_history(Some("project_a"), 10).unwrap();
+        let history_b = pm.load_history(Some("project_b"), 10).unwrap();
 
         assert_eq!(history_a.len(), 1);
         assert_eq!(history_b.len(), 1);
@@ -511,45 +514,45 @@ mod tests {
 
     #[test]
     fn test_reservoir_persistence() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
+        let pm = PersistenceManager::new_in_memory().unwrap();
 
         let mut esn = EchoStateNetwork::new(384, 1000, 100, 0.7, 0.95);
 
         // Update state to make it non-default
         let input = vec![0.5; 384];
         esn.update(&input);
 
-        pm.save_reservoir_state(Some("test_project"), &esn).expect("TODO: handle error");
+        pm.save_reservoir_state(Some("test_project"), &esn).unwrap();
 
-        let loaded = pm.load_reservoir_state(Some("test_project")).expect("TODO: handle error");
+        let loaded = pm.load_reservoir_state(Some("test_project")).unwrap();
         assert!(loaded.is_some());
 
         // Verify we can use the loaded ESN
-        let mut loaded_esn = loaded.expect("TODO: handle error");
+        let mut loaded_esn = loaded.unwrap();
         let output = loaded_esn.output();
         assert_eq!(output.len(), 100);
     }
 
     #[test]
     fn test_mlp_persistence() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
+        let pm = PersistenceManager::new_in_memory().unwrap();
 
         let mlp = MLP::new(384, vec![100, 50], 3);
-        pm.save_mlp("router", &mlp, Some(0.85)).expect("TODO: handle error");
+        pm.save_mlp("router", &mlp, Some(0.85)).unwrap();
 
-        let loaded = pm.load_mlp("router").expect("TODO: handle error");
+        let loaded = pm.load_mlp("router").unwrap();
         assert!(loaded.is_some());
 
         // Verify we can use the loaded MLP
-        let loaded_mlp = loaded.expect("TODO: handle error");
+        let loaded_mlp = loaded.unwrap();
         let input = vec![0.5; 384];
         let output = loaded_mlp.forward(&input);
         assert_eq!(output.len(), 3);
     }
 
     #[test]
     fn test_clear_history() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
+        let pm = PersistenceManager::new_in_memory().unwrap();
 
         for i in 0..10 {
             let turn = ConversationTurn {
@@ -566,18 +569,18 @@ mod tests {
                     },
                 },
             };
-            pm.save_turn(None, &turn).expect("TODO: handle error");
+            pm.save_turn(None, &turn).unwrap();
         }
 
-        assert_eq!(pm.conversation_count(None).expect("TODO: handle error"), 10);
+        assert_eq!(pm.conversation_count(None).unwrap(), 10);
 
-        pm.clear_history(None).expect("TODO: handle error");
-        assert_eq!(pm.conversation_count(None).expect("TODO: handle error"), 0);
+        pm.clear_history(None).unwrap();
+        assert_eq!(pm.conversation_count(None).unwrap(), 0);
     }
 
     #[test]
     fn test_history_limit() {
-        let pm = PersistenceManager::new_in_memory().expect("TODO: handle error");
+        let pm = PersistenceManager::new_in_memory().unwrap();
 
         let base_timestamp = current_timestamp();
         for i in 0..100 {
@@ -599,10 +602,10 @@ mod tests {
                     },
                 },
             };
-            pm.save_turn(None, &turn).expect("TODO: handle error");
+            pm.save_turn(None, &turn).unwrap();
         }
 
-        let history = pm.load_history(None, 10).expect("TODO: handle error");
+        let history = pm.load_history(None, 10).unwrap();
         assert_eq!(history.len(), 10);
 
         // Should get most recent 10 (90-99) in chronological order (oldest first)

src/reservoir.rs

@@ -379,8 +379,8 @@ mod tests {
         let esn = EchoStateNetwork::new(10, 50, 5, 0.7, 0.95);
 
         // Should be serializable
-        let json = serde_json::to_string(&esn).expect("TODO: handle error");
-        let deserialized: EchoStateNetwork = serde_json::from_str(&json).expect("TODO: handle error");
+        let json = serde_json::to_string(&esn).unwrap();
+        let deserialized: EchoStateNetwork = serde_json::from_str(&json).unwrap();
 
         assert_eq!(esn.reservoir_size, deserialized.reservoir_size);
         assert_eq!(esn.state, deserialized.state);

src/snn.rs

@@ -314,7 +314,7 @@ mod tests {
     #[test]
     fn test_spiking_network_serialization() {
         let snn = SpikingNetwork::new(10, 20, 3);
-        let json = serde_json::to_string(&snn).expect("TODO: handle error");
-        let _deserialized: SpikingNetwork = serde_json::from_str(&json).expect("TODO: handle error");
+        let json = serde_json::to_string(&snn).unwrap();
+        let _deserialized: SpikingNetwork = serde_json::from_str(&json).unwrap();
     }
 }

src/training.rs

@@ -521,7 +521,7 @@ mod tests {
         let mut esn = EchoStateNetwork::new(10, 100, 5, 0.7, 0.95);
 
         let trainer = ReservoirTrainer::new(0.01);
-        let mse = trainer.train(&mut esn, &inputs, &targets).expect("TODO: handle error");
+        let mse = trainer.train(&mut esn, &inputs, &targets).unwrap();
 
         // Should learn with reasonable error
         assert!(mse < 1.0);