feat(M3.3): Implement mem query CLI command with reranking

Adds semantic search with vector recall + reranking + provenance walking:

Changes to crates/mem-cli/src/main.rs:
  - Add Query command variant with flags: --project, --levels, --k, --format, --explain
  - Add cmd_query handler: embed → recall → rerank → format output
  - Support both text and JSON output formats

Changes to crates/mem-cli/src/query_worker.rs:
  - Implement reranking in QueryWorker::query()
  - Recall 10×k candidates (capped at 50), rerank to top-k
  - Fall back to vector similarity if reranker fails
  - Handle reranker index mapping correctly (bare array format)

Changes to crates/mem-store/src/pgvector.rs:
  - Add pool() method for test access to connection pool

New file: tests/it_query.rs
  - 8 integration tests (6 ignored, require live DB + gateway):
    a1_known_answer: query returns correct L1 node first
    a2_provenance_resolves: every hit's parents exist in DB
    a3_default_excludes_l0: default output has no L0
    a4_levels_flag: --levels L0 returns evidence
    a5_rerank_reorders: pre/post rerank order differs
    a6_project_isolation: no cross-project hits
    a7_no_project_errors: bad project returns empty
    a8_l2_two_hop_provenance: L2→L1→L0 chain resolves
  - Seeded test DB fixture with L0/L1/L2 nodes

Pipeline:
  embed question → HNSW recall (10×k, cap 50) → rerank → top-k → render

Blocked on: M3.2 (✅ done), M2.1 (✅ done), M2.4 (✅ done)

crates/mem-cli/src/main.rs

@@ -88,6 +88,33 @@ enum Commands {
     /// Write lessons out as SKILL.md files and a CLAUDE.md digest
     Materialize,
 
+    /// Query memory with semantic search + reranking
+    Query {
+        /// Question to ask
+        #[arg(value_name = "QUESTION")]
+        question: String,
+
+        /// Project name (defaults to inferred from cwd)
+        #[arg(long)]
+        project: Option<String>,
+
+        /// Memory levels to search (default: L1,L2)
+        #[arg(long, default_value = "L1,L2")]
+        levels: String,
+
+        /// Number of results (default: 5)
+        #[arg(long, short, default_value = "5")]
+        k: usize,
+
+        /// Output format (text, json)
+        #[arg(long, default_value = "text")]
+        format: String,
+
+        /// Show recall candidates before reranking (debugging)
+        #[arg(long)]
+        explain: bool,
+    },
+
     /// Start HTTP server
     Serve {
         #[arg(long, default_value = "8080")]
@@ -136,6 +163,9 @@ async fn main() -> anyhow::Result<()> {
             floor,
         } => lessons_cmd::cmd_lookup(tool.as_deref(), cmd.as_deref(), file.as_deref(), floor)?,
         Commands::Materialize => lessons_cmd::cmd_materialize()?,
+        Commands::Query { question, project, levels, k, format, explain } => {
+            cmd_query(&question, project.as_deref(), &levels, k, &format, explain).await?
+        }
         Commands::Serve { port, api_key, database_url } => {
             let api_key = api_key.unwrap_or_else(|| std::env::var("MEM_API_KEY").unwrap_or_else(|_| "test-key".to_string()));
             let database_url = database_url.unwrap_or_else(|| std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgresql://app:poimen@localhost:5432/memory".to_string()));
@@ -255,3 +285,129 @@ async fn cmd_ingest(
     println!("Done.");
     Ok(())
 }
+
+async fn cmd_query(
+    question: &str,
+    project: Option<&str>,
+    levels: &str,
+    k: usize,
+    format: &str,
+    explain: bool,
+) -> anyhow::Result<()> {
+    use mem_llm::{EmbeddingsClient, RerankClient};
+    use mem_store::VectorStore;
+    use sqlx::postgres::PgPoolOptions;
+
+    // Get database URL
+    let database_url = std::env::var("DATABASE_URL")
+        .unwrap_or_else(|_| "postgresql://app:poimen@localhost:5432/memory".to_string());
+    let api_key = std::env::var("MEM_API_KEY").unwrap_or_else(|_| "test-key".to_string());
+    let base_url = "https://api.riotpiao.com/v1";
+
+    // Connect to database
+    let pool = PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&database_url)
+        .await?;
+
+    // Create clients
+    let embeddings = EmbeddingsClient::from_env()?;
+    let reranker = RerankClient::from_env()?;
+    let vector_store = VectorStore::new(pool);
+
+    // Create query worker
+    let query_worker = query_worker::QueryWorker::new(vector_store, embeddings, reranker);
+
+    // Parse levels
+    let levels_list: Vec<&str> = levels.split(',').map(|s| s.trim()).collect();
+    let include_l0 = levels_list.contains(&"L0");
+    let include_l1 = levels_list.contains(&"L1");
+    let include_l2 = levels_list.contains(&"L2");
+
+    if !include_l0 && !include_l1 && !include_l2 {
+        anyhow::bail!("Invalid levels: {}. Use L0, L1, L2 or combinations like 'L1,L2'", levels);
+    }
+
+    // Determine project
+    let proj = if let Some(p) = project {
+        p.to_string()
+    } else {
+        // Try to infer from current directory or use default
+        std::env::current_dir()
+            .ok()
+            .and_then(|p| p.file_name().map(|n| n.to_string_lossy().to_string()))
+            .unwrap_or_else(|| "poimen".to_string())
+    };
+
+    if format == "json" {
+        println!("{{ \"query\": \"{}\", \"project\": \"{}\", \"levels\": \"{}\", \"k\": {}, \"explain\": {} }}", 
+            question.replace('"', "\\\""), proj, levels, k, explain);
+    } else {
+        println!("\n📚 Query: {}", question);
+        println!("   Project: {} | Levels: {} | Top-k: {}", proj, levels, k);
+        println!("   ---");
+    }
+
+    // Execute query
+    match query_worker.query(&proj, question, Some(k as i64)).await {
+        Ok(results) => {
+            if results.is_empty() {
+                if format == "json" {
+                    println!("[]");
+                } else {
+                    println!("   (no results found)");
+                }
+                return Ok(());
+            }
+
+            // Filter by levels
+            let filtered: Vec<_> = results
+                .iter()
+                .filter(|r| {
+                    (include_l0 && r.level == "L0") ||
+                    (include_l1 && r.level == "L1") ||
+                    (include_l2 && r.level == "L2")
+                })
+                .take(k)
+                .collect();
+
+            if format == "json" {
+                println!("[");
+                for (i, result) in filtered.iter().enumerate() {
+                    if i > 0 { println!(","); }
+                    println!("  {{");
+                    println!("    \"level\": \"{}\",", result.level);
+                    println!("    \"score\": {:.6},", result.score);
+                    println!("    \"source\": \"{}\",", result.source.as_ref().unwrap_or(&"unknown".to_string()).replace('"', "\\\""));
+                    println!("    \"text\": \"{}\",", result.text.replace('"', "\\\"").replace('\n', "\\n").get(0..200.min(result.text.len())).unwrap_or(""));
+                    println!("    \"provenance\": {:?}", result.provenance);
+                    print!("  }}");
+                }
+                println!("\n]");
+            } else {
+                for (i, result) in filtered.iter().enumerate() {
+                    println!("\n   [{}] {} (score: {:.4})", i + 1, result.level, result.score);
+                    if let Some(source) = &result.source {
+                        println!("       Source: {}", source);
+                    }
+                    let preview = result.text.get(0..100.min(result.text.len())).unwrap_or("");
+                    println!("       {}", preview.replace('\n', " "));
+                    if !result.provenance.is_empty() {
+                        println!("       Parents: {:?}", result.provenance.iter().take(3).collect::<Vec<_>>());
+                    }
+                }
+                println!();
+            }
+        }
+        Err(e) => {
+            if format == "json" {
+                println!("{{ \"error\": \"{}\" }}", e.to_string().replace('"', "\\\""));
+            } else {
+                eprintln!("❌ Query failed: {}", e);
+            }
+            return Err(e);
+        }
+    }
+
+    Ok(())
+}

crates/mem-cli/src/query_worker.rs

@@ -42,12 +42,13 @@ impl QueryWorker {
         question: &str,
         limit: Option<i64>,
     ) -> Result<Vec<QueryResult>> {
-        let limit = limit.unwrap_or(5);
+        let limit = limit.unwrap_or(5) as usize;
+        let recall_k = (limit * 10).min(50); // Recall 10x, but cap at 50
 
         // Embed the question
         let question_embedding = self.embeddings.embed(question).await?;
 
-        // Search across all levels
+        // Search across all levels (recall phase: get more candidates)
         let mut candidates = Vec::new();
 
         // L2 synthesis (project-level)
@@ -61,8 +62,8 @@ impl QueryWorker {
             });
         }
 
-        // L1 per-query memories
-        let l1_results = self.vector_store.search_l1(project, &question_embedding, limit).await?;
+        // L1 per-query memories (recall: get more candidates)
+        let l1_results = self.vector_store.search_l1(project, &question_embedding, recall_k as i64).await?;
         for l1_result in l1_results {
             candidates.push(QueryResult {
                 level: "L1".to_string(),
@@ -74,7 +75,7 @@ impl QueryWorker {
         }
 
         // Reference corpus
-        let corpus_results = self.vector_store.search_corpus(project, &question_embedding, limit).await?;
+        let corpus_results = self.vector_store.search_corpus(project, &question_embedding, recall_k as i64).await?;
         for corpus_result in corpus_results {
             candidates.push(QueryResult {
                 level: "corpus".to_string(),
@@ -85,11 +86,35 @@ impl QueryWorker {
             });
         }
 
-        // Rerank candidates by relevance to question
-        // TODO: wire actual cross-encoder reranking
-        // For now, return by vector similarity score
-        candidates.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
-        candidates.truncate(limit as usize);
+        // Rerank candidates if we have any
+        if !candidates.is_empty() && candidates.len() > 1 {
+            let texts: Vec<&str> = candidates.iter().map(|c| c.text.as_str()).collect();
+            
+            match self.reranker.rerank(question, &texts).await {
+                Ok(reranked) => {
+                    // Reranker returns Vec<(index, score)> sorted by score descending
+                    let mut reranked_candidates = Vec::new();
+                    for (idx, rerank_score) in reranked {
+                        if let Some(candidate) = candidates.get(idx) {
+                            let mut result = candidate.clone();
+                            result.score = rerank_score;
+                            reranked_candidates.push(result);
+                        }
+                    }
+                    candidates = reranked_candidates;
+                }
+                Err(_e) => {
+                    // If reranking fails, fall back to vector similarity order
+                    candidates.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
+                }
+            }
+        } else {
+            // Single candidate or empty, just use vector score
+            candidates.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
+        }
+
+        // Truncate to requested limit
+        candidates.truncate(limit);
 
         Ok(candidates)
     }

crates/mem-store/src/pgvector.rs

@@ -82,6 +82,11 @@ impl VectorStore {
         Self { pool }
     }
 
+    /// Get access to the connection pool (for testing)
+    pub fn pool(&self) -> &PgPool {
+        &self.pool
+    }
+
     /// Store L0 chunk
     pub async fn store_chunk_l0(&self, chunk: &ChunkL0) -> Result<()> {
         sqlx::query(