feat: M3.7.4 Context Endpoint - three-tier lookup infrastructure (12 tests)

crates/mem-cli/src/http_server.rs

@@ -354,6 +354,7 @@ pub async fn start_server(port: u16, api_key: String, database_url: &str) -> Res
             .route("/memory/ingest", web::post().to(ingest_handler))
             .route("/memory/ingest/{ingest_id}", web::get().to(ingest_status))
             .route("/memory/query", web::get().to(query_handler))
+            .route("/memory/context", web::post().to(context_handler))
             .route("/memory/projects", web::get().to(projects_handler))
             .route("/memory/skills", web::get().to(skills_handler))
             .route("/memory/vault/generate", web::post().to(vault_generate_handler))
@@ -821,6 +822,55 @@ pub async fn skills_handler(
     }
 }
 
+/// POST /memory/context — three-tier context lookup for failure diagnosis
+pub async fn context_handler(
+    req: HttpRequest,
+    body: web::Json<crate::context_endpoint::ContextRequest>,
+    state: web::Data<AppState>,
+) -> HttpResponse {
+    let (claims, _token) = match validate_auth(&req, &state).await {
+        Ok(c) => c,
+        Err(e) => return e,
+    };
+
+    // Check read capability
+    if !has_capability(&claims, "memory:read") {
+        return HttpResponse::Forbidden().json(json!({
+            "error": "forbidden",
+            "reason": "missing capability: memory:read"
+        }));
+    }
+
+    if let Err(e) = check_rate_limit(&claims, &state, "/memory/context") {
+        return e;
+    }
+
+    let project = body.project.clone().unwrap_or_else(|| "all".to_string());
+    let scope = body.scope.clone().unwrap_or_else(|| "project".to_string());
+    let budget = body.budget.unwrap_or(6000);
+
+    let lookup = crate::context_endpoint::ContextLookup::new(budget, project, scope);
+
+    match lookup.lookup(body.into_inner()).await {
+        Ok(response) => {
+            tracing::info!(
+                tier = response.tier,
+                lessons = response.lessons.len(),
+                skills = response.skills.len(),
+                "context lookup successful"
+            );
+            HttpResponse::Ok().json(response)
+        }
+        Err(e) => {
+            tracing::error!("context lookup error: {}", e);
+            HttpResponse::BadRequest().json(json!({
+                "error": "lookup_failed",
+                "reason": e.to_string()
+            }))
+        }
+    }
+}
+
 /// POST /memory/vault/generate — generate Obsidian vault from memories
 pub async fn vault_generate_handler(
     req: HttpRequest,