.gitea/workflows/build.yaml

@@ -11,6 +11,7 @@ env:
   REGISTRY: forgejo.riotpiao.com
   IMAGE: forgejo.riotpiao.com/rock/poimen-memory
   DOCKER_HOST: tcp://localhost:2375
+  SQLX_OFFLINE: "true"
 
 jobs:
   ci:

crates/mem-cli/src/agent/client_sdk.rs

@@ -227,7 +227,7 @@ impl SynthesisClient {
     ) -> Vec<Result<ClientResponse, String>> {
         let mut results = Vec::new();
         for req in requests {
-            results.push(self.execute(&req).await);
+            results.push(self.execute(req).await);
         }
         results
     }
@@ -280,11 +280,12 @@ impl SynthesisClient {
             tracing::debug!("Workflow executed in {}ms", elapsed_ms);
             Ok(body)
         } else {
+            let status = response.status();
             let error_text = response
                 .text()
                 .await
                 .unwrap_or_else(|_| "unknown error".to_string());
-            Err(format!("Workflow failed ({}): {}", response.status(), error_text))
+            Err(format!("Workflow failed ({}): {}", status, error_text))
         }
     }
 }

crates/mem-cli/src/agent/mod.rs

@@ -11,6 +11,4 @@ pub use agent_interface::{Agent, AgentConfig, AgentCapability};
 pub use webhook_handler::{WebhookEvent, WebhookPayload};
 pub use observability::{AgentMetrics, MetricsCollector};
 pub use client_sdk::{SynthesisClient, ClientRequest, ClientResponse};
-
-/// Default agent implementation (type alias for Agent)
-pub type DefaultAgent = Agent;
+pub use agent_interface::DefaultAgent;

crates/mem-cli/src/auth/authentik_service_account.rs

@@ -5,7 +5,7 @@ use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 use serde::{Deserialize, Serialize};
 use reqwest::Client;
-use log::{debug, warn, error};
+use tracing::{debug, warn, error};
 
 #[derive(Clone, Debug)]
 pub struct AuthentikServiceAccountConfig {

crates/mem-cli/src/auth_middleware.rs

@@ -59,15 +59,17 @@ pub fn auth_error_response(error: &AuthError) -> HttpResponse {
     let (status, message) = match error {
         AuthError::MissingToken => ("Unauthorized", "Missing or invalid Authorization header"),
         AuthError::InvalidSignature => ("Unauthorized", "Invalid token signature"),
-        AuthError::ExpiredToken => ("Unauthorized", "Token has expired"),
+        AuthError::TokenExpired => ("Unauthorized", "Token has expired"),
         AuthError::InvalidIssuer => ("Unauthorized", "Invalid token issuer"),
-        AuthError::AccessDenied => ("Forbidden", "Access denied for this resource"),
-        AuthError::InvalidClaims => ("Unauthorized", "Invalid or missing required claims"),
+        AuthError::InvalidAudience => ("Unauthorized", "Invalid token audience"),
+        AuthError::ProviderUnavailable(_) => ("ServiceUnavailable", "Auth provider unavailable"),
+        AuthError::Other(_) => ("Unauthorized", "Authentication error"),
     };
 
     HttpResponse::build(match status {
         "Unauthorized" => actix_web::http::StatusCode::UNAUTHORIZED,
         "Forbidden" => actix_web::http::StatusCode::FORBIDDEN,
+        "ServiceUnavailable" => actix_web::http::StatusCode::SERVICE_UNAVAILABLE,
         _ => actix_web::http::StatusCode::INTERNAL_SERVER_ERROR,
     })
     .json(json!({

crates/mem-cli/src/compaction.rs

@@ -19,7 +19,7 @@ pub trait LlmCaller: Send + Sync {
 }
 
 /// Compaction statistics
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, serde::Serialize)]
 pub struct CompactionStats {
     pub duplicate_edges_deleted: usize,
     pub stale_facts_deleted: usize,

crates/mem-cli/src/handlers/middleware.rs

@@ -41,7 +41,7 @@ pub fn validate_and_rate_limit(
                 }))
             })?;
 
-        jwt_validator.validate_bearer_token(auth_header).map_err(|e| {
+        crate::jwt_validator::JwtValidator::extract_bearer_token(auth_header).map_err(|e| {
             HttpResponse::Unauthorized().json(json!({
                 "error": format!("JWT validation failed: {}", e)
             }))
@@ -51,10 +51,10 @@ pub fn validate_and_rate_limit(
     // 2. Rate limiting (if enabled)
     state
         .rate_limiter
-        .check_limit(endpoint, rate_limit)
+        .check("default", endpoint)
         .map_err(|e| {
             HttpResponse::TooManyRequests().json(json!({
-                "error": format!("Rate limit exceeded: {}", e)
+                "error": format!("Rate limit exceeded: {}", e.reason())
             }))
         })?;
 

crates/mem-cli/src/handlers/ranking_handler.rs

@@ -171,7 +171,7 @@ pub struct RankedResult {
 /// GET /memory/ranking/profiles
 pub async fn get_ranking_profiles(req: HttpRequest) -> HttpResponse {
     // Verify auth
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));

crates/mem-cli/src/handlers/rebuild_handler.rs

@@ -54,7 +54,7 @@ pub async fn rebuild(
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
     // Verify auth
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));
@@ -155,7 +155,7 @@ pub async fn rebuild_status(
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
     // Verify auth
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));

crates/mem-cli/src/handlers/semantic.rs

@@ -142,8 +142,8 @@ pub async fn search_entities_handler(
            body.query, body.entity_type, body.start_time, body.end_time);
 
     // 3. Embed query
-    let query_embedding = match state.embeddings.embed_text(&body.query).await {
-        Ok(emb) => emb,
+    let query_embedding = match state.embeddings.embed_one(&body.query).await {
+        Ok(emb) => emb.to_vec(),
         Err(e) => {
             error!("Embedding failed: {}", e);
             return crate::handlers::response_builder::internal_error(
@@ -278,8 +278,8 @@ pub async fn search_edges_handler(
            body.query, body.relation_type, body.start_time, body.end_time);
 
     // 3. Embed query
-    let query_embedding = match state.embeddings.embed_text(&body.query).await {
-        Ok(emb) => emb,
+    let query_embedding = match state.embeddings.embed_one(&body.query).await {
+        Ok(emb) => emb.to_vec(),
         Err(e) => {
             error!("Embedding failed: {}", e);
             return crate::handlers::response_builder::internal_error(
@@ -361,8 +361,8 @@ pub async fn hybrid_search_handler(
            body.query, body.semantic_weight, body.lexical_weight);
 
     // 3. Embed query
-    let query_embedding = match state.embeddings.embed_text(&body.query).await {
-        Ok(emb) => emb,
+    let query_embedding = match state.embeddings.embed_one(&body.query).await {
+        Ok(emb) => emb.to_vec(),
         Err(e) => {
             error!("Embedding failed: {}", e);
             return crate::handlers::response_builder::internal_error(

crates/mem-cli/src/handlers/synthesis.rs

@@ -517,11 +517,12 @@ pub async fn reasoning_paths_handler(
     let elapsed = start_time.elapsed().as_millis();
     info!("Paths: {} found in {}ms", paths.len(), elapsed);
 
+    let path_count = paths.len();
     crate::handlers::response_builder::success_response(ReasoningPathsResponse {
         source_id: body.source_id.clone(),
         target_id: body.target_id.clone(),
         paths,
-        path_count: paths.len(),
+        path_count,
         process_time_ms: elapsed,
     })
 }

crates/mem-cli/src/handlers/unified_query.rs

@@ -136,8 +136,8 @@ pub async fn unified_query_handler(
            body.search_type, body.query, body.entity_type, body.relation_type);
 
     // 3. Embed query once (reused for all search types)
-    let query_embedding = match state.embeddings.embed_text(&body.query).await {
-        Ok(emb) => emb,
+    let query_embedding = match state.embeddings.embed_one(&body.query).await {
+        Ok(emb) => emb.to_vec(),
         Err(e) => {
             error!("Embedding failed: {}", e);
             return crate::handlers::response_builder::internal_error(

crates/mem-cli/src/handlers/unified_synthesis.rs

@@ -158,12 +158,12 @@ pub async fn unified_synthesis_handler(
     // Entity Linking
     if body.link_entities {
         let linker = EntityLinker::new(state.pool.clone());
-        match linker.link_entities(&body.content) {
-            Ok(links) => {
+        match linker.link_mentions(&body.content, &body.project).await {
+            Ok((links, _unlinked)) => {
                 let alias_count = links.iter().filter(|l| l.confidence > 0.85).count();
                 entity_linking = Some(EntityLinkingResult {
                     mention_links: links.iter().map(|l| MentionLinkResponse {
-                        mention: l.mention.clone(),
+                        mention: l.mention_text.clone(),
                         entity_id: l.entity_id.clone(),
                         confidence: l.confidence,
                     }).collect(),
@@ -179,14 +179,14 @@ pub async fn unified_synthesis_handler(
 
     // Inference
     if body.infer_facts {
-        let engine = InferenceEngine::new(state.pool.clone());
-        match engine.infer_facts(&body.content, 5, 0.6, &body.project) {
+        let engine = InferenceEngine::new(state.pool.clone(), vec![]);
+        match engine.infer_facts(&body.project, &body.content, 5).await {
             Ok(facts) => {
                 inference = Some(InferenceResult {
                     inferred_facts: facts.iter().map(|f| InferredFactResponse {
-                        source: f.source.clone(),
-                        relation: f.relation.clone(),
-                        target: f.target.clone(),
+                        source: f.source_id.clone(),
+                        relation: f.relation_type.clone(),
+                        target: f.target_id.clone(),
                         confidence: f.confidence,
                     }).collect(),
                     fact_count: facts.len(),

crates/mem-cli/src/handlers/versioning_handler.rs

@@ -15,7 +15,7 @@ pub async fn get_entity_versions(
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
     // Verify auth
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));
@@ -46,7 +46,7 @@ pub async fn get_entity_version(
     path: web::Path<(String, i32)>,
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));
@@ -80,7 +80,7 @@ pub async fn get_entity_diff(
     query: web::Query<DiffQuery>,
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));
@@ -120,7 +120,7 @@ pub async fn get_entity_at_time(
     query: web::Query<TimeQuery>,
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));
@@ -164,7 +164,7 @@ pub async fn get_edge_versions(
     path: web::Path<Uuid>,
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));
@@ -196,7 +196,7 @@ pub async fn get_edge_diff(
     query: web::Query<DiffQuery>,
     pool: web::Data<PgPool>,
 ) -> HttpResponse {
-    if let Err(e) = AuthGuard::extract_token(&req) {
+    if let Err(e) = AuthGuard::extract_token(req.headers().get("Authorization").and_then(|v| v.to_str().ok()).unwrap_or("")) {
         return HttpResponse::Unauthorized().json(json!({
             "error": e.to_string()
         }));

crates/mem-cli/src/handlers/visualize_sse.rs

@@ -145,13 +145,15 @@ pub async fn visualize_stream_handler(
         match execute_streaming_visualization(&state, req_body).await {
             Ok(events) => {
                 for event in events {
-                    yield format_sse_event(event);
+                    let data = format_sse_event(event);
+                    yield Ok::<actix_web::web::Bytes, actix_web::Error>(actix_web::web::Bytes::from(data));
                 }
             }
             Err(e) => {
-                yield format_sse_event(VisualizeEvent::Error {
+                let data = format_sse_event(VisualizeEvent::Error {
                     message: e,
                 });
+                yield Ok::<actix_web::web::Bytes, actix_web::Error>(actix_web::web::Bytes::from(data));
             }
         }
     };
@@ -161,7 +163,7 @@ pub async fn visualize_stream_handler(
         .insert_header(("Cache-Control", "no-cache"))
         .insert_header(("Connection", "keep-alive"))
         .insert_header(("Transfer-Encoding", "chunked"))
-        .streaming_body(Box::pin(stream))
+        .streaming(Box::pin(stream))
 }
 
 /// Execute streaming visualization (generates events)

crates/mem-cli/src/parallel_dual_write.rs

@@ -116,13 +116,13 @@ impl ParallelDualWriteIndexer {
 
         // Spawn background task (non-blocking)
         tokio::spawn(async move {
-            let result = opensearch.index_chunk(
+            let result = opensearch.index_document(
                 &chunk_id,
                 &chunk.content,
                 &chunk.source,
-                &chunk.project,
                 &chunk.level,
-                &chunk.breadcrumb.join(" > "),
+                chunk.breadcrumb.clone(),
+                "",  // jwt_token - not available in background task
             ).await;
 
             match result {
@@ -139,8 +139,8 @@ impl ParallelDualWriteIndexer {
         &self,
         chunks: Vec<(&IndexableChunk, Vec<f32>)>,
     ) -> Vec<DualWriteResult> {
-        let futures = chunks.into_iter().map(|(chunk, embedding)| {
-            self.index_parallel(chunk, &embedding)
+        let futures = chunks.into_iter().map(|(chunk, embedding)| async move {
+            self.index_parallel(chunk, &embedding).await
         });
 
         futures::future::join_all(futures)

crates/mem-cli/src/query/bfs_graph_traversal.rs

@@ -6,7 +6,7 @@
 use std::collections::{HashMap, VecDeque};
 use serde::{Deserialize, Serialize};
 use chrono::{DateTime, Utc};
-use sqlx::{Pool, Postgres};
+use sqlx::{Pool, Postgres, Row};
 
 /// A node in the traversal result
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -196,6 +196,7 @@ impl BfsGraphTraversal {
             });
         }
         
+        let edge_count = edges.len();
         Ok(GraphData {
             nodes,
             edges,
@@ -203,7 +204,7 @@ impl BfsGraphTraversal {
             requested_depth: config.max_depth,
             max_depth_reached: max_depth,
             node_count: visited.len(),
-            edge_count: edges.len(),
+            edge_count,
             depth_breakdown,
             traversal_time_ms: start_time.elapsed().as_millis() as u64,
         })

crates/mem-cli/src/query/community_detector.rs

@@ -185,9 +185,9 @@ impl CommunityDetector {
 
                 communities_vec.push(Community {
                     id: comm_id,
+                    size: members.len(),
                     entity_ids: members.into_iter().collect(),
                     entity_names,
-                    size: members.len(),
                     modularity_contribution: modularity_contrib,
                     average_strength: strength,
                     density,
@@ -196,9 +196,9 @@ impl CommunityDetector {
         }
 
         // 5. Calculate total modularity
-        let total_modularity = communities_vec
+        let total_modularity: f64 = communities_vec
             .iter()
-            .map(|c| c.modularity_contribution)
+            .map(|c| c.modularity_contribution as f64)
             .sum();
 
         let average_community_size = if communities_vec.is_empty() {
@@ -210,9 +210,9 @@ impl CommunityDetector {
         let result = CommunityDetectionResult {
             entity_count: entities.len(),
             edge_count: edges.len(),
-            communities: communities_vec,
             community_count: communities_vec.len(),
-            total_modularity: total_modularity.max(-1.0).min(1.0),
+            communities: communities_vec,
+            total_modularity: total_modularity.max(-1.0).min(1.0) as f32,
             average_community_size,
         };
 

crates/mem-cli/src/query/faceted_search.rs

@@ -3,7 +3,7 @@
 //! Enables multi-dimensional filtering across entities and edges.
 //! Supports entity types, relation types, date ranges, confidence levels, and more.
 
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, Timelike, Utc};
 use serde::{Deserialize, Serialize};
 use sqlx::{Pool, Postgres};
 use std::collections::HashMap;
@@ -42,7 +42,7 @@ pub struct AvailableFacets {
 }
 
 /// Facet filters for a query
-#[derive(Debug, Clone, Default, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct FacetFilters {
     /// Filter by entity types (OR within facet, AND across facets)
     pub entity_types: Option<Vec<String>>,

crates/mem-cli/src/query/force_directed_layout.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use super::bfs_graph_traversal::{GraphData, TraversalNode, TraversalEdge};
 
 /// 2D position (X, Y coordinates)
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
 pub struct Position {
     pub x: f32,
     pub y: f32,

crates/mem-cli/src/query/inference_engine.rs

@@ -4,6 +4,8 @@
 //! confidence propagation through reasoning chains.
 
 use std::collections::{HashMap, HashSet, VecDeque};
+use std::pin::Pin;
+use std::future::Future;
 use sqlx::PgPool;
 use serde::{Deserialize, Serialize};
 use tracing::{debug, warn};
@@ -293,18 +295,19 @@ impl InferenceEngine {
     }
 
     /// DFS to find all paths
-    async fn dfs_paths(
-        &self,
-        current: &str,
-        target: &str,
-        project_id: &str,
+    fn dfs_paths<'a>(
+        &'a self,
+        current: &'a str,
+        target: &'a str,
+        project_id: &'a str,
         remaining_hops: usize,
-        path: &mut Vec<String>,
-        relations: &mut Vec<String>,
-        confidences: &mut Vec<f32>,
-        visited: &mut HashSet<String>,
-        results: &mut Vec<ReasoningPath>,
-    ) -> Result<(), String> {
+        path: &'a mut Vec<String>,
+        relations: &'a mut Vec<String>,
+        confidences: &'a mut Vec<f32>,
+        visited: &'a mut HashSet<String>,
+        results: &'a mut Vec<ReasoningPath>,
+    ) -> Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'a>> {
+        Box::pin(async move {
         if remaining_hops == 0 {
             return Ok(());
         }
@@ -350,6 +353,7 @@ impl InferenceEngine {
         }
 
         Ok(())
+        }) // Box::pin
     }
 }
 

crates/mem-cli/src/query/path_finder.rs

@@ -6,6 +6,8 @@
 use serde::{Deserialize, Serialize};
 use sqlx::{Pool, Postgres};
 use std::collections::{HashMap, HashSet, VecDeque};
+use std::pin::Pin;
+use std::future::Future;
 use tracing::{debug, info};
 
 /// A single path through the graph
@@ -123,13 +125,14 @@ impl PathFinder {
                     info!("Found shortest path: {} → {} (distance: {})", 
                           source_id, target_id, final_entities.len() - 1);
 
+                    let distance = final_entities.len() - 1;
                     return Ok(Some(Path {
                         source_id: source_id.to_string(),
                         target_id: target_id.to_string(),
                         entity_ids: final_entities,
                         entity_names: vec![],  // Could fetch from DB if needed
                         relation_types: final_relations,
-                        distance: final_entities.len() - 1,
+                        distance,
                         total_confidence: final_confidence.max(0.0).min(1.0),
                     }));
                 }
@@ -293,19 +296,20 @@ impl PathFinder {
     }
 
     /// DFS helper for finding all paths
-    async fn dfs_paths(
-        &self,
-        source_id: &str,
-        target_id: &str,
+    fn dfs_paths<'a>(
+        &'a self,
+        source_id: &'a str,
+        target_id: &'a str,
         current_path: Vec<String>,
         relations_path: Vec<String>,
         confidence: f32,
         depth: usize,
         max_depth: usize,
-        paths_found: &mut Vec<Path>,
-        visited: &mut HashSet<String>,
+        paths_found: &'a mut Vec<Path>,
+        visited: &'a mut HashSet<String>,
         max_paths: usize,
-    ) -> Result<(), String> {
+    ) -> Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'a>> {
+        Box::pin(async move {
         if paths_found.len() >= max_paths {
             return Ok(());  // Found enough paths
         }
@@ -328,13 +332,14 @@ impl PathFinder {
 
                 let final_confidence = confidence * edge.confidence;
 
+                let distance = final_path.len() - 1;
                 paths_found.push(Path {
                     source_id: source_id.to_string(),
                     target_id: target_id.to_string(),
                     entity_ids: final_path,
                     entity_names: vec![],
                     relation_types: final_relations,
-                    distance: final_path.len() - 1,
+                    distance,
                     total_confidence: final_confidence.max(0.0).min(1.0),
                 });
 
@@ -370,6 +375,7 @@ impl PathFinder {
         }
 
         Ok(())
+        }) // Box::pin
     }
 
     /// Fetch direct neighbors of an entity

crates/mem-cli/src/query/semantic_retriever.rs

@@ -138,7 +138,7 @@ impl SemanticRetriever {
             .await
             .map_err(|e| format!("Database error: {}", e))?;
 
-        let entities = results
+        let entities: Vec<_> = results
             .into_iter()
             .map(|(id, name, entity_type, score, metadata)| EntityResult {
                 id,
@@ -213,7 +213,7 @@ impl SemanticRetriever {
             .await
             .map_err(|e| format!("Database error: {}", e))?;
 
-        let edges = results
+        let edges: Vec<_> = results
             .into_iter()
             .map(|(id, src_id, tgt_id, src_name, tgt_name, rel_type, fact, score, conf)| {
                 EdgeResult {

crates/mem-cli/src/query/summarizer.rs

@@ -261,7 +261,7 @@ impl Summarizer {
     }
 
     /// Split text into sentences
-    fn split_sentences(&self, text: &str) -> Vec<&str> {
+    fn split_sentences<'a>(&self, text: &'a str) -> Vec<&'a str> {
         text.split('.').map(|s| s.trim()).filter(|s| !s.is_empty()).collect()
     }
 
@@ -331,7 +331,7 @@ impl Summarizer {
 
                 let overlap = entities1
                     .iter()
-                    .filter(|e| entities2.contains(e))
+                    .filter(|e| entities2.contains(*e))
                     .count();
                 coherence += overlap as f32 / (entities1.len().max(entities2.len()) as f32).max(1.0);
             }

crates/mem-cli/src/query_router.rs

@@ -245,6 +245,8 @@ impl QueryRouter {
             prefilter_size,
             metrics,
             latency_ms,
+            confidence_score: 1.0,
+            is_valid: true,
         })
     }