fix(recall): prefer smart_score as ranking key in RecalledMemory (#154)

* fix(recall): prefer smart_score as ranking key in RecalledMemory deserialization

Server sorts recall results by smart_score (fallback weighted_score → score) but
RecalledMemory::deserialize only read score and weighted_score, causing .score to
differ from the actual rank order. Fix prioritizes smart_score, exposing the raw
smart_score and weighted_score as Option<f32> fields for analytics consumers.

Tests: 4 unit tests covering smart_score priority, weighted_score fallback, raw
score fallback, and flat-format decode.

Co-Authored-By: Paperclip <noreply@paperclip.ing>

* fix(fmt): apply rustfmt — multi-line option chains and assert_eq wraps

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: SDK Lead <sdk-lead@dakera.ai>
Co-authored-by: Paperclip <noreply@paperclip.ing>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: 4 people

src/memory.rs

@@ -442,7 +442,14 @@ pub struct RecalledMemory {
     pub content: String,
     pub memory_type: MemoryType,
     pub importance: f32,
+    /// The ranking score — equals `smart_score` when present, then `weighted_score`, then raw `score`.
     pub score: f32,
+    /// Raw smart_score from the server (the primary ranking key).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub smart_score: Option<f32>,
+    /// Raw weighted_score from the server.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub weighted_score: Option<f32>,
     #[serde(default)]
     pub tags: Vec<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -465,12 +472,20 @@ impl<'de> serde::Deserialize<'de> for RecalledMemory {
         let val = serde_json::Value::deserialize(deserializer)?;
 
         // Server wraps recall results as {memory:{...}, score, weighted_score, smart_score}.
+        // smart_score is the actual ranking key (server sorts by it); prefer it.
         // Fall back to flat format for direct memory-get responses.
-        let score = val
-            .get("score")
+        let smart_score = val
+            .get("smart_score")
+            .and_then(|v| v.as_f64())
+            .map(|v| v as f32);
+        let weighted_score = val
+            .get("weighted_score")
             .and_then(|v| v.as_f64())
-            .or_else(|| val.get("weighted_score").and_then(|v| v.as_f64()))
-            .unwrap_or(0.0) as f32;
+            .map(|v| v as f32);
+        let score = smart_score
+            .or(weighted_score)
+            .or_else(|| val.get("score").and_then(|v| v.as_f64()).map(|v| v as f32))
+            .unwrap_or(0.0);
 
         let mem = val.get("memory").unwrap_or(&val);
 
@@ -518,6 +533,8 @@ impl<'de> serde::Deserialize<'de> for RecalledMemory {
             memory_type,
             importance,
             score,
+            smart_score,
+            weighted_score,
             tags,
             session_id,
             metadata,

tests/smart_score_test.rs

@@ -0,0 +1,64 @@
+//! Tests for RecalledMemory score field priority (smart_score > weighted_score > score).
+
+use dakera_client::RecalledMemory;
+
+fn deserialize(json: &str) -> RecalledMemory {
+    serde_json::from_str(json).expect("deserialization failed")
+}
+
+#[test]
+fn test_smart_score_takes_priority() {
+    let json = r#"{
+        "memory": {"id": "m1", "content": "test", "memory_type": "episodic", "importance": 0.8, "created_at": 1000, "last_accessed_at": 1000, "access_count": 0, "tags": []},
+        "score": 0.5,
+        "weighted_score": 0.7,
+        "smart_score": 0.9
+    }"#;
+    let m = deserialize(json);
+    assert_eq!(m.score, 0.9, ".score must equal smart_score when present");
+    assert_eq!(m.smart_score, Some(0.9));
+    assert_eq!(m.weighted_score, Some(0.7));
+}
+
+#[test]
+fn test_weighted_score_used_when_no_smart_score() {
+    let json = r#"{
+        "memory": {"id": "m2", "content": "test", "memory_type": "episodic", "importance": 0.8, "created_at": 1000, "last_accessed_at": 1000, "access_count": 0, "tags": []},
+        "score": 0.5,
+        "weighted_score": 0.7
+    }"#;
+    let m = deserialize(json);
+    assert_eq!(
+        m.score, 0.7,
+        ".score must equal weighted_score when smart_score absent"
+    );
+    assert_eq!(m.smart_score, None);
+    assert_eq!(m.weighted_score, Some(0.7));
+}
+
+#[test]
+fn test_raw_score_fallback() {
+    let json = r#"{
+        "memory": {"id": "m3", "content": "test", "memory_type": "episodic", "importance": 0.8, "created_at": 1000, "last_accessed_at": 1000, "access_count": 0, "tags": []},
+        "score": 0.5
+    }"#;
+    let m = deserialize(json);
+    assert_eq!(
+        m.score, 0.5,
+        ".score must equal raw score when no smart_score or weighted_score"
+    );
+    assert_eq!(m.smart_score, None);
+    assert_eq!(m.weighted_score, None);
+}
+
+#[test]
+fn test_flat_format_score_fallback() {
+    // Flat format (direct memory-get, no envelope)
+    let json = r#"{
+        "id": "m4", "content": "flat", "memory_type": "episodic", "importance": 0.5,
+        "score": 0.6, "created_at": 1000, "last_accessed_at": 1000, "access_count": 0, "tags": []
+    }"#;
+    let m = deserialize(json);
+    assert_eq!(m.score, 0.6);
+    assert_eq!(m.smart_score, None);
+}