fix(recall): wire the layer filter (#269 follow-up)

RecallParams.layer was accepted but never applied (dead field -> 'never read'
warning). Now filters by biomimetic layer in all modes: fts5_search +
fts5_bm25_search pre-filter in-query; a mode-agnostic post-filter in recall()
covers the dense arm of dense/hybrid (dense_search has no RecallParams access).
world/episodic/semantic aliases normalized to core/buffer/working at the tools
layer (handle_recall + expansion path). Test covers canonical + alias + no-filter.
105 tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: tcconnally

CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to Mimir are documented here. This project adheres to
 
 ## [Unreleased]
 
+### Fixed
+- **`layer` filter on `mimir_recall` now actually filters (#269 follow-up).** The
+  `layer` recall parameter was accepted but never applied — `RecallParams.layer`
+  was a dead field. It now filters by biomimetic layer in all three modes:
+  keyword (`fts5_search`) and BM25 (`fts5_bm25_search`) pre-filter in-query, and a
+  mode-agnostic post-filter in `recall()` covers the dense arm of dense/hybrid
+  (which scores vectors without `RecallParams` access). Aliases world/episodic/
+  semantic are normalized to core/buffer/working at the tools layer.
+
 ### Added
 - **`include_confidence` on `mimir_recall` (#287).** Opt-in (default false): each result
   gains a normalized `confidence` (0.0–1.0) rolled up from rank, trust (verified/certainty),

src/db.rs

@@ -1467,6 +1467,18 @@ impl Database {
     }
 
     /// Search entities with FTS5 + LIKE fallback and optional filters.
+    /// Drop entities whose layer doesn't match `params.layer` (when set). Applied
+    /// post-search so it also covers the dense arm of dense/hybrid recall, which
+    /// scores vectors without access to RecallParams (#269/#272). The keyword
+    /// paths additionally pre-filter in-query (cheaper, pre-limit).
+    fn retain_layer(entities: &mut Vec<Entity>, params: &RecallParams) {
+        if let Some(ref layer) = params.layer {
+            if !layer.is_empty() {
+                entities.retain(|e| e.layer == *layer);
+            }
+        }
+    }
+
     pub fn recall(&self, params: &RecallParams) -> Result<Vec<Entity>, Box<dyn std::error::Error>> {
         // Dense vector search path
         if params.mode == crate::models::SearchMode::Dense
@@ -1489,7 +1501,9 @@ impl Database {
             if let Some(query_vec) = query_vec {
                 if params.mode == crate::models::SearchMode::Dense {
                     let dense_results = self.dense_search(query_vec, params.limit as usize)?;
-                    return Ok(dense_results.into_iter().map(|(e, _)| e).collect());
+                    let mut out: Vec<Entity> = dense_results.into_iter().map(|(e, _)| e).collect();
+                    Self::retain_layer(&mut out, params);
+                    return Ok(out);
                 }
 
                 // Hybrid: fuse the dense vectors with a read-only, BM25-ranked,
@@ -1523,12 +1537,16 @@ impl Database {
                     params.recency_half_life_secs,
                     now_ms(),
                 );
-                return Ok(fused.into_iter().map(|(e, _)| e).collect());
+                let mut out: Vec<Entity> = fused.into_iter().map(|(e, _)| e).collect();
+                Self::retain_layer(&mut out, params);
+                return Ok(out);
             }
             // Empty query: nothing to embed, fall through to FTS5
         }
 
-        self.fts5_search(params)
+        let mut results = self.fts5_search(params)?;
+        Self::retain_layer(&mut results, params);
+        Ok(results)
     }
 
     /// Core FTS5 + LIKE keyword search (extracted for reuse by recall and hybrid).
@@ -1650,6 +1668,16 @@ impl Database {
             param_values.push(Box::new(aid.clone()));
         }
 
+        // Filter by biomimetic memory layer (#269/#272): core/buffer/working.
+        // Aliases (world/episodic/semantic) are normalized to canonical layers
+        // by the tools layer before reaching here.
+        if let Some(ref layer) = params.layer {
+            if !layer.is_empty() {
+                conditions.push(format!("layer = ?{}", param_values.len() + 1));
+                param_values.push(Box::new(layer.clone()));
+            }
+        }
+
         // Exclude archived unless explicitly requested
         if !params.include_archived {
             conditions.push("archived = 0".to_string());
@@ -1898,6 +1926,13 @@ impl Database {
             conditions.push(format!("e.agent_id = ?{}", param_values.len() + 1));
             param_values.push(Box::new(aid.clone()));
         }
+        // Biomimetic layer filter (#269/#272): core/buffer/working.
+        if let Some(ref layer) = params.layer {
+            if !layer.is_empty() {
+                conditions.push(format!("e.layer = ?{}", param_values.len() + 1));
+                param_values.push(Box::new(layer.clone()));
+            }
+        }
 
         let safe_limit = params.limit.clamp(0, 1000);
         let limit_idx = param_values.len() + 1;

src/tools.rs

@@ -139,6 +139,19 @@ fn apply_confidence(items: &mut [serde_json::Value], entities: &[crate::models::
     }
 }
 
+/// Map a biomimetic layer alias (world/episodic/semantic) to its canonical
+/// storage layer (core/buffer/working). Any other value passes through, so
+/// callers may also filter by the raw layer name.
+fn canonical_layer(s: &str) -> String {
+    match s {
+        "world" => "core",
+        "episodic" => "buffer",
+        "semantic" => "working",
+        other => other,
+    }
+    .to_string()
+}
+
 fn default_halving() -> f64 {
     1.0
 }
@@ -421,7 +434,7 @@ pub fn handle_recall(db: &Database, args: Value) -> Result<String, String> {
         workspace_hash: a.workspace_hash.clone(),
         agent_id: a.agent_id.clone(),
         visibility: None,
-        layer: a.layer.clone(),
+        layer: a.layer.as_deref().filter(|s| !s.is_empty()).map(canonical_layer),
     };
 
     let entities = db
@@ -551,7 +564,7 @@ fn handle_recall_with_expansion(db: &Database, a: &RecallArgs) -> Result<String,
             workspace_hash: a.workspace_hash.clone(),
             agent_id: a.agent_id.clone(),
             visibility: None,
-            layer: a.layer.clone(),
+            layer: a.layer.as_deref().filter(|s| !s.is_empty()).map(canonical_layer),
         };
 
         if let Ok(entities) = db.recall(&params) {