Merge pull request #397 from AdaWorldAPI/claude/sprint-13-codex-p2-fixes-pr395-pr396

fix(sprint-13/codex-p2): D-CSV-14 gen=0 + D-CSV-16 cam_pq_search semantics

Author: AdaWorldAPI

crates/lance-graph/src/graph/arigraph/witness_corpus.rs

@@ -409,20 +409,12 @@ impl WitnessCorpus {
         evicted
     }
 
-    /// Top-k query by SPO.
+    /// Exact-match top-k query by SPO.
     ///
-    /// With `with-cam-pq` ON and cam_pq_state Some: distance-ranked via CAM-PQ ADC.
-    /// Otherwise: HashMap chain-order fallback.
+    /// Always returns entries whose `spo` exactly equals the query; never
+    /// returns unrelated neighbours. For distance-ranked nearest-neighbour
+    /// search, use `query_similar` (feature `with-cam-pq`).
     pub fn cam_pq_search(&self, spo: u64, k: usize) -> Vec<&WitnessEntry> {
-        #[cfg(feature = "with-cam-pq")]
-        if let Some(state) = self.cam_pq_state.as_ref() {
-            return state
-                .index
-                .cam_pq_search(spo, k)
-                .into_iter()
-                .filter_map(|(pos, _dist)| self.entries.get(pos))
-                .collect();
-        }
         self.cam_pq_index
             .lookup(spo)
             .iter()
@@ -979,6 +971,39 @@ mod tests {
         assert_eq!(idx.len(), 0);
     }
 
+    // Codex P2 (PR #396): cam_pq_search must remain exact-match even when
+    // CAM-PQ is enabled. ANN search lives on query_similar. Asserts that a
+    // missing SPO yields an empty result (not k unrelated neighbours) and
+    // that an existing SPO yields only its own entries.
+    #[cfg(feature = "with-cam-pq")]
+    #[test]
+    fn cam_pq_search_exact_match_when_cam_pq_enabled() {
+        let mut corpus = WitnessCorpus::new();
+        let spo_a = 0xAAAA_u64;
+        let spo_b = 0xBBBB_u64;
+        for ts in [100u64, 200, 300] {
+            corpus.insert(make_entry(spo_a, ts));
+        }
+        for ts in [10u64, 20, 30] {
+            corpus.insert(make_entry(spo_b, ts));
+        }
+        corpus.enable_cam_pq(tiny_codebook(), 0xCAFE_BABE);
+
+        let hits_a = corpus.cam_pq_search(spo_a, 5);
+        assert_eq!(hits_a.len(), 3, "must return exactly the 3 spo_a entries");
+        assert!(
+            hits_a.iter().all(|e| e.spo == spo_a),
+            "no unrelated neighbours allowed"
+        );
+
+        let missing = corpus.cam_pq_search(0xCCCC_u64, 5);
+        assert!(
+            missing.is_empty(),
+            "missing SPO must return empty, not k nearest neighbours; got {} entries",
+            missing.len()
+        );
+    }
+
     // T12: feature OFF smoke — WitnessCorpus::new() and query() work.
     // (Compiles and runs under both feature flags; tests only HashMap path.)
     #[test]

crates/thinking-engine/src/splat_ops.rs

@@ -53,6 +53,15 @@ pub fn splat_gaussian(
 ) {
     let mut think = Think::from_field(std::mem::take(field), generation.saturating_sub(1));
     think.splat_gaussian(mean, variance, energy);
+    // For generation == 0, saturating_sub(1) underflows to 0 and the method's
+    // advance_cycle() then writes generation=1, diverging from v1 verbatim
+    // semantics. Restore by overwriting the touched splat (matched by `mean`).
+    for s in think.splat_field.iter_mut() {
+        if s.mean == mean {
+            s.generation = generation;
+            break;
+        }
+    }
     *field = think.splat_field;
 }
 
@@ -169,6 +178,28 @@ mod tests {
         assert_eq!(field_shim[0].generation, think.splat_field[0].generation);
     }
 
+    #[test]
+    #[allow(deprecated)]
+    fn deprecated_splat_gaussian_preserves_generation_zero() {
+        // Codex P2 (PR #395): caller passing generation=0 must see the v1
+        // verbatim semantics (stored generation == 0), not the off-by-one
+        // produced by Think::splat_gaussian advancing cycle from 0 → 1.
+        let mut field_push: Vec<SplatField> = Vec::new();
+        splat_gaussian(&mut field_push, 7, 1.0, 1.0, 0);
+        assert_eq!(field_push.len(), 1);
+        assert_eq!(field_push[0].generation, 0, "push path: gen=0 verbatim");
+
+        let mut field_merge: Vec<SplatField> = vec![SplatField {
+            mean: 9,
+            variance: 1.0,
+            energy: 2.0,
+            generation: 42,
+        }];
+        splat_gaussian(&mut field_merge, 9, 1.0, 3.0, 0);
+        assert_eq!(field_merge.len(), 1);
+        assert_eq!(field_merge[0].generation, 0, "merge path: gen=0 verbatim");
+    }
+
     #[test]
     #[allow(deprecated)]
     fn deprecated_score_hole_closure_forwards_to_method() {