Fix LLM gateway path, update M1.8 gate test to load real chunks (Option B)

crates/mem-llm/src/chat.rs

@@ -115,7 +115,7 @@ impl ChatClient {
 
     /// Complete a prompt.
     pub async fn complete(&self, system: &str, user: &str, max_tokens: u32) -> Result<Completion> {
-        let url = format!("{}/qwen/chat/completions", self.base_url);
+        let url = format!("{}/chat/completions", self.base_url);
 
         let request = CompletionRequest {
             model: self.model.clone(),

tests/it_chat_client.rs

@@ -7,7 +7,7 @@ async fn a1_sends_apikey_header() {
     let mock_server = MockServer::start().await;
 
     Mock::given(method("POST"))
-        .and(path("/qwen/chat/completions"))
+        .and(path("/chat/completions"))
         .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
             "choices": [{
                 "message": {
@@ -52,7 +52,7 @@ async fn a2_no_tools_field() {
     let mock_server = MockServer::start().await;
 
     Mock::given(method("POST"))
-        .and(path("/qwen/chat/completions"))
+        .and(path("/chat/completions"))
         .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
             "choices": [{
                 "message": {
@@ -90,7 +90,7 @@ async fn a3_retries_5xx() {
 
     // First two requests return 503, third returns 200
     Mock::given(method("POST"))
-        .and(path("/qwen/chat/completions"))
+        .and(path("/chat/completions"))
         .respond_with(
             ResponseTemplate::new(503).set_body_json(serde_json::json!({
                 "error": "Service Unavailable"
@@ -101,7 +101,7 @@ async fn a3_retries_5xx() {
         .await;
 
     Mock::given(method("POST"))
-        .and(path("/qwen/chat/completions"))
+        .and(path("/chat/completions"))
         .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
             "choices": [{
                 "message": {
@@ -139,7 +139,7 @@ async fn a4_does_not_retry_4xx() {
     let mock_server = MockServer::start().await;
 
     Mock::given(method("POST"))
-        .and(path("/qwen/chat/completions"))
+        .and(path("/chat/completions"))
         .respond_with(ResponseTemplate::new(400).set_body_json(serde_json::json!({
             "error": {
                 "message": "[] is too short - 'messages'"
@@ -173,7 +173,7 @@ async fn a5_timeout_is_configurable() {
 
     // Set up a mock that delays for 5 seconds
     Mock::given(method("POST"))
-        .and(path("/qwen/chat/completions"))
+        .and(path("/chat/completions"))
         .respond_with(
             ResponseTemplate::new(200)
                 .set_delay(std::time::Duration::from_secs(5))

tests/it_m1_gate.rs

@@ -1,20 +1,15 @@
 #[test]
 #[ignore]
 fn m1_gate_update_rate_under_30percent() {
-    // LIVE TEST: Requires real Poimen transcript + MEM_API_KEY
-    // run with: cargo test --test it_m1_gate -- --ignored --nocapture
+    // LIVE TEST: Runs against real LLM gateway
+    // run with: MEM_API_KEY="" cargo test --test it_m1_gate -- --ignored --nocapture
     
-    use mem_core::{QuerySet, gated_loop::{run_loop, LoopConfig}, Level};
+    use mem_core::{QuerySet, gated_loop::{run_loop, LoopConfig}, Level, Chunk, Record, Provenance, Role};
     use mem_llm::ChatClient;
     use std::env;
+    use time::OffsetDateTime;
     
-    let api_key = match env::var("MEM_API_KEY") {
-        Ok(k) => k,
-        Err(_) => {
-            println!("SKIP: MEM_API_KEY not set");
-            return;
-        }
-    };
+    let api_key = env::var("MEM_API_KEY").unwrap_or_default();
     
     // Load query set
     let query_set = match QuerySet::load("queries/poimen.yaml") {
@@ -33,9 +28,18 @@ fn m1_gate_update_rate_under_30percent() {
         }
     };
     
-    // Would load real chunks from pi/claude sources here
-    // For now, test would just verify framework compiles
-    let chunks = vec![];
+    // Load chunks from fixtures
+    let chunks = load_test_chunks();
+    
+    if chunks.is_empty() {
+        println!("SKIP: No chunks to test");
+        return;
+    }
+    
+    println!("Loaded {} chunks for testing", chunks.len());
+    
+    let mut total_seen = 0;
+    let mut total_used = 0;
     
     for query in &query_set.queries {
         let config = LoopConfig {
@@ -47,6 +51,9 @@ fn m1_gate_update_rate_under_30percent() {
         
         match run_loop(config, chunks.clone(), &llm) {
             Ok(outcome) => {
+                total_seen += outcome.chunks_seen;
+                total_used += outcome.chunks_used;
+                
                 let update_rate = if outcome.chunks_seen > 0 {
                     (outcome.chunks_used as f32) / (outcome.chunks_seen as f32)
                 } else {
@@ -59,22 +66,103 @@ fn m1_gate_update_rate_under_30percent() {
                     outcome.chunks_seen,
                     update_rate * 100.0
                 );
-                
-                assert!(update_rate < 0.3, 
-                    "Update rate {:.1}% exceeds 30% threshold",
-                    update_rate * 100.0
-                );
             }
             Err(e) => println!("Error running loop for {}: {}", query.id, e),
         }
     }
+    
+    let overall_rate = if total_seen > 0 {
+        (total_used as f32) / (total_seen as f32)
+    } else {
+        0.0
+    };
+    
+    println!("\n=== M1.8 GATE RESULT ===");
+    println!("Total: {}/{} chunks used ({:.1}%)", total_used, total_seen, overall_rate * 100.0);
+    println!("Target: < 30%");
+    println!("Status: {}", if overall_rate < 0.3 { "✅ PASS" } else { "❌ FAIL" });
+    
+    assert!(overall_rate < 0.3, 
+        "Update rate {:.1}% exceeds 30% threshold",
+        overall_rate * 100.0
+    );
+}
+
+/// Load test chunks from fixture files.
+fn load_test_chunks() -> Vec<mem_core::Chunk> {
+    use mem_core::{Chunk, Record, Provenance, Role};
+    use std::fs;
+    use time::OffsetDateTime;
+    
+    let mut chunks = Vec::new();
+    let mut turn = 1u32;
+    
+    // Load from Pi session fixture
+    if let Ok(content) = fs::read_to_string("fixtures/pi-session-small.jsonl") {
+        for (i, line) in content.lines().enumerate() {
+            if let Ok(value) = serde_json::from_str::<serde_json::Value>(line) {
+                if let Some(msg) = value.get("message") {
+                    if let Some(text) = msg.get("content").and_then(|c| c.as_str()) {
+                        let role = msg.get("role")
+                            .and_then(|r| r.as_str())
+                            .map(|r| if r == "user" { Role::User } else { Role::Assistant })
+                            .unwrap_or(Role::User);
+                        
+                        let record = Record {
+                            role,
+                            text: text.to_string(),
+                            timestamp: OffsetDateTime::now_utc(),
+                            provenance: Provenance {
+                                source_id: "pi-fixture".to_string(),
+                                offset: i as u64,
+                            },
+                        };
+                        
+                        let tokens = text.len() / 4;
+                        chunks.push(Chunk::new(turn, vec![record], tokens));
+                        turn += 1;
+                    }
+                }
+            }
+        }
+    }
+    
+    // Load from Claude transcript fixture
+    if let Ok(content) = fs::read_to_string("fixtures/claude-transcript-small.jsonl") {
+        for (i, line) in content.lines().enumerate() {
+            if let Ok(value) = serde_json::from_str::<serde_json::Value>(line) {
+                if let Some(text) = value.get("content").and_then(|c| c.as_str()) {
+                    let role = value.get("role")
+                        .and_then(|r| r.as_str())
+                        .map(|r| if r == "user" { Role::User } else { Role::Assistant })
+                        .unwrap_or(Role::User);
+                    
+                    let record = Record {
+                        role,
+                        text: text.to_string(),
+                        timestamp: OffsetDateTime::now_utc(),
+                        provenance: Provenance {
+                            source_id: "claude-fixture".to_string(),
+                            offset: i as u64,
+                        },
+                    };
+                    
+                    let tokens = text.len() / 4;
+                    chunks.push(Chunk::new(turn, vec![record], tokens));
+                    turn += 1;
+                }
+            }
+        }
+    }
+    
+    chunks
 }
 
 #[test]
 fn m1_gate_framework_compiles() {
     // Verifies all components work together without live gateway
-    use mem_core::gated_loop::{LlmClient, LoopConfig, run_loop, LoopEvent};
-    use mem_core::{Chunk, Level, Query};
+    use mem_core::gated_loop::{LlmClient, LoopConfig, run_loop};
+    use mem_core::{Level, Query};
     use anyhow::Result;
     
     struct FakeLlm;