feat: apply PR #6, #9, #10 from doctatortot

- test(api): install rustls CryptoProvider in setup_app (PR #6)
  Fixes ~20 api test failures from missing TLS provider

- fix(retrieve): replace min-max RRF normalization with scale-and-clamp (PR #9)
  Preserves absolute quality signal; weak matches no longer inflate to 1.0
  RRF_SCALE=61 so ideal dual-leg rank-1 maps to ~1.0. Closes #7

- feat(api): expose memory_type on create and update (PR #10)
  POST /v1/memories accepts memory_type (pinned|insight|session)
  PUT /v1/memories/:id can change memory_type
  Default remains 'pinned' for backwards compat

Co-authored-by: doctatortot <doctatortot@users.noreply.github.com>

Author: yhyyz

omem-server/src/api/handlers/memory.rs

@@ -37,6 +37,7 @@ pub struct CreateMemoryBody {
     #[serde(default)]
     pub tags: Option<Vec<String>>,
     pub source: Option<String>,
+    pub memory_type: Option<String>,
 }
 
 #[derive(Deserialize)]
@@ -95,6 +96,7 @@ pub struct UpdateMemoryBody {
     pub content: Option<String>,
     pub tags: Option<Vec<String>>,
     pub state: Option<String>,
+    pub memory_type: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -204,10 +206,15 @@ pub async fn create_memory(
         return Err(OmemError::Validation("content cannot be empty".to_string()));
     }
 
+    let memory_type = match body.memory_type {
+        Some(s) => s.parse().map_err(OmemError::Validation)?,
+        None => MemoryType::Pinned,
+    };
+
     let mut memory = Memory::new(
         &content,
         Category::Preferences,
-        MemoryType::Pinned,
+        memory_type,
         &auth.tenant_id,
     );
     memory.tags = body.tags.unwrap_or_default();
@@ -553,6 +560,12 @@ pub async fn update_memory(
             .map_err(|e: String| OmemError::Validation(e))?;
     }
 
+    if let Some(memory_type_str) = body.memory_type {
+        memory.memory_type = memory_type_str
+            .parse()
+            .map_err(|e: String| OmemError::Validation(e))?;
+    }
+
     memory.updated_at = chrono::Utc::now().to_rfc3339();
 
     let vector = if need_reembed {

omem-server/src/api/mod.rs

@@ -51,7 +51,16 @@ mod tests {
         }
     }
 
+    fn install_crypto_provider() {
+        use std::sync::Once;
+        static INIT: Once = Once::new();
+        INIT.call_once(|| {
+            let _ = rustls::crypto::ring::default_provider().install_default();
+        });
+    }
+
     async fn setup_app() -> (axum::Router, tempfile::TempDir) {
+        install_crypto_provider();
         let dir = tempfile::TempDir::new().expect("temp dir");
         let uri = dir.path().to_str().expect("path");
 
@@ -481,6 +490,153 @@ mod tests {
         assert_eq!(json["tags"][0], "new-tag");
     }
 
+    #[tokio::test]
+    async fn test_create_memory_with_type() {
+        let (app, _dir) = setup_app().await;
+        let api_key = create_test_tenant(&app).await;
+
+        let create_resp = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/v1/memories")
+                    .header("content-type", "application/json")
+                    .header("x-api-key", &api_key)
+                    .body(Body::from(
+                        r#"{"content":"an insight","memory_type":"insight"}"#,
+                    ))
+                    .expect("request"),
+            )
+            .await
+            .expect("response");
+        let bytes = create_resp
+            .into_body()
+            .collect()
+            .await
+            .expect("body")
+            .to_bytes();
+        let created: serde_json::Value = serde_json::from_slice(&bytes).expect("json");
+        assert_eq!(created["memory_type"], "insight");
+
+        let default_resp = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/v1/memories")
+                    .header("content-type", "application/json")
+                    .header("x-api-key", &api_key)
+                    .body(Body::from(r#"{"content":"default"}"#))
+                    .expect("request"),
+            )
+            .await
+            .expect("response");
+        let bytes = default_resp
+            .into_body()
+            .collect()
+            .await
+            .expect("body")
+            .to_bytes();
+        let default_created: serde_json::Value = serde_json::from_slice(&bytes).expect("json");
+        assert_eq!(default_created["memory_type"], "pinned");
+    }
+
+    #[tokio::test]
+    async fn test_update_memory_type() {
+        let (app, _dir) = setup_app().await;
+        let api_key = create_test_tenant(&app).await;
+
+        let create_resp = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/v1/memories")
+                    .header("content-type", "application/json")
+                    .header("x-api-key", &api_key)
+                    .body(Body::from(r#"{"content":"originally pinned"}"#))
+                    .expect("request"),
+            )
+            .await
+            .expect("response");
+        let bytes = create_resp
+            .into_body()
+            .collect()
+            .await
+            .expect("body")
+            .to_bytes();
+        let created: serde_json::Value = serde_json::from_slice(&bytes).expect("json");
+        let memory_id = created["id"].as_str().expect("id");
+        assert_eq!(created["memory_type"], "pinned");
+
+        let update_resp = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("PUT")
+                    .uri(format!("/v1/memories/{memory_id}"))
+                    .header("content-type", "application/json")
+                    .header("x-api-key", &api_key)
+                    .body(Body::from(r#"{"memory_type":"insight"}"#))
+                    .expect("request"),
+            )
+            .await
+            .expect("response");
+        assert_eq!(update_resp.status(), StatusCode::OK);
+        let bytes = update_resp
+            .into_body()
+            .collect()
+            .await
+            .expect("body")
+            .to_bytes();
+        let json: serde_json::Value = serde_json::from_slice(&bytes).expect("json");
+        assert_eq!(json["memory_type"], "insight");
+    }
+
+    #[tokio::test]
+    async fn test_update_memory_type_invalid() {
+        let (app, _dir) = setup_app().await;
+        let api_key = create_test_tenant(&app).await;
+
+        let create_resp = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/v1/memories")
+                    .header("content-type", "application/json")
+                    .header("x-api-key", &api_key)
+                    .body(Body::from(r#"{"content":"test"}"#))
+                    .expect("request"),
+            )
+            .await
+            .expect("response");
+        let bytes = create_resp
+            .into_body()
+            .collect()
+            .await
+            .expect("body")
+            .to_bytes();
+        let created: serde_json::Value = serde_json::from_slice(&bytes).expect("json");
+        let memory_id = created["id"].as_str().expect("id");
+
+        let update_resp = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("PUT")
+                    .uri(format!("/v1/memories/{memory_id}"))
+                    .header("content-type", "application/json")
+                    .header("x-api-key", &api_key)
+                    .body(Body::from(r#"{"memory_type":"bogus"}"#))
+                    .expect("request"),
+            )
+            .await
+            .expect("response");
+        assert_eq!(update_resp.status(), StatusCode::BAD_REQUEST);
+    }
+
     #[tokio::test]
     async fn test_search_memories() {
         let (app, _dir) = setup_app().await;

omem-server/src/retrieve/pipeline.rs

@@ -300,36 +300,18 @@ impl RetrievalPipeline {
         (fused, stage)
     }
 
-    /// Normalize RRF scores to [0, 1] range so downstream thresholds (min_score, hard_cutoff) work correctly.
-    /// RRF raw scores are tiny (max ~0.033 for K=60 with 2 legs), but thresholds expect [0, 1].
-    /// - Multiple results: min-max normalization (best=1.0, worst=0.0)
-    /// - Single result: scale by RRF_SCALE (40.0) and clamp to [0, 1]
+    /// Normalize RRF scores into [0, 1] while preserving absolute quality signal.
+    /// Raw RRF scores are tiny (~1/(K+1) for ideal dual-leg rank-1 match with K=60),
+    /// but downstream thresholds (min_score, hard_cutoff) expect [0, 1]. We scale by
+    /// RRF_SCALE so the best-possible hybrid match maps to ~1.0 and clamp; everything
+    /// weaker stays proportionally smaller.
     fn stage_rrf_normalize(mut entries: Vec<FusionEntry>) -> (Vec<FusionEntry>, StageTrace) {
-        const RRF_SCALE: f32 = 40.0;
+        const RRF_SCALE: f32 = 61.0;
         let stage_start = Instant::now();
         let input_count = entries.len();
 
-        if entries.len() > 1 {
-            let max_score = entries
-                .iter()
-                .map(|e| e.rrf_score)
-                .fold(f32::NEG_INFINITY, f32::max);
-            let min_score = entries
-                .iter()
-                .map(|e| e.rrf_score)
-                .fold(f32::INFINITY, f32::min);
-            let range = max_score - min_score;
-            if range > 0.0 {
-                for entry in &mut entries {
-                    entry.rrf_score = (entry.rrf_score - min_score) / range;
-                }
-            } else if max_score > 0.0 {
-                for entry in &mut entries {
-                    entry.rrf_score = 1.0;
-                }
-            }
-        } else if entries.len() == 1 {
-            entries[0].rrf_score = (entries[0].rrf_score * RRF_SCALE).min(1.0);
+        for entry in &mut entries {
+            entry.rrf_score = (entry.rrf_score * RRF_SCALE).clamp(0.0, 1.0);
         }
 
         let score_range = fusion_score_range(&entries);
@@ -1160,48 +1142,64 @@ mod tests {
 
     #[test]
     fn test_rrf_normalize_multiple_results() {
+        let ideal = 1.0 / 61.0;
         let entries = vec![
-            make_entry("best", 0.033),
-            make_entry("mid", 0.020),
-            make_entry("worst", 0.010),
+            make_entry("best", ideal),
+            make_entry("mid", ideal * 0.5),
+            make_entry("worst", ideal * 0.25),
         ];
 
         let (result, stage) = RetrievalPipeline::stage_rrf_normalize(entries);
         assert_eq!(stage.name, "rrf_normalize");
         assert_eq!(result.len(), 3);
 
         let best = result.iter().find(|e| e.memory.content == "best").unwrap();
-        let worst = result.iter().find(|e| e.memory.content == "worst").unwrap();
         let mid = result.iter().find(|e| e.memory.content == "mid").unwrap();
+        let worst = result.iter().find(|e| e.memory.content == "worst").unwrap();
 
         assert!(
-            (best.rrf_score - 1.0).abs() < 1e-6,
-            "best should be 1.0, got {}",
+            (best.rrf_score - 1.0).abs() < 1e-4,
+            "ideal RRF should map to ~1.0, got {}",
             best.rrf_score
         );
         assert!(
-            (worst.rrf_score - 0.0).abs() < 1e-6,
-            "worst should be 0.0, got {}",
+            (mid.rrf_score - 0.5).abs() < 1e-4,
+            "half-ideal RRF should map to ~0.5, got {}",
+            mid.rrf_score
+        );
+        assert!(
+            (worst.rrf_score - 0.25).abs() < 1e-4,
+            "quarter-ideal RRF should map to ~0.25, got {}",
             worst.rrf_score
         );
+        assert!(best.rrf_score > mid.rrf_score && mid.rrf_score > worst.rrf_score);
+    }
+
+    #[test]
+    fn test_rrf_normalize_weak_top_not_inflated() {
+        let entries = vec![
+            make_entry("weak-top", 0.003),
+            make_entry("weak-mid", 0.002),
+            make_entry("weak-bot", 0.001),
+        ];
+
+        let (result, _) = RetrievalPipeline::stage_rrf_normalize(entries);
+        let top = result.iter().find(|e| e.memory.content == "weak-top").unwrap();
         assert!(
-            mid.rrf_score > 0.0 && mid.rrf_score < 1.0,
-            "mid should be between 0 and 1, got {}",
-            mid.rrf_score
+            top.rrf_score < 0.25,
+            "weak top result should stay below 0.25, got {}",
+            top.rrf_score
         );
     }
 
     #[test]
     fn test_rrf_normalize_single_result() {
-        let entries = vec![make_entry("only", 0.016)];
+        let entries = vec![make_entry("only", 1.0 / 61.0)];
 
         let (result, _) = RetrievalPipeline::stage_rrf_normalize(entries);
         assert_eq!(result.len(), 1);
         let score = result[0].rrf_score;
-        assert!(
-            (score - 0.64).abs() < 1e-4,
-            "0.016 * 40 = 0.64, got {score}"
-        );
+        assert!((score - 1.0).abs() < 1e-4, "1/61 * 61 = 1.0, got {score}");
     }
 
     #[test]
@@ -1218,11 +1216,22 @@ mod tests {
 
     #[test]
     fn test_rrf_normalize_equal_scores() {
-        let entries = vec![make_entry("a", 0.016), make_entry("b", 0.016)];
+        let entries = vec![make_entry("a", 1.0 / 61.0), make_entry("b", 1.0 / 61.0)];
+
+        let (result, _) = RetrievalPipeline::stage_rrf_normalize(entries);
+        assert!((result[0].rrf_score - 1.0).abs() < 1e-4);
+        assert!((result[1].rrf_score - 1.0).abs() < 1e-4);
+    }
+
+    #[test]
+    fn test_rrf_normalize_equal_weak_scores() {
+        let entries = vec![make_entry("a", 0.005), make_entry("b", 0.005)];
 
         let (result, _) = RetrievalPipeline::stage_rrf_normalize(entries);
-        assert!((result[0].rrf_score - 1.0).abs() < 1e-6);
-        assert!((result[1].rrf_score - 1.0).abs() < 1e-6);
+        let expected = 0.005_f32 * 61.0;
+        assert!((result[0].rrf_score - expected).abs() < 1e-4);
+        assert!((result[1].rrf_score - expected).abs() < 1e-4);
+        assert!(result[0].rrf_score < 0.5);
     }
 
     #[test]