feat: TD-INT-5 corrected + TD-INT-8 + TD-INT-11 — palette distance, schema validation, neural-debug registry

TD-INT-5 (CORRECTED) — per-plane palette distance via ndarray:
  REVERTED hamming_in_slice from role_keys.rs — slicing/comparison
  algebra belongs in ndarray, not in lance-graph-contract. RoleKey
  stays Layer-2 catalogue (slice boundaries only).

  ADDED PlaneDistance in lance-graph-planner/cache/convergence.rs:
  wraps ndarray::hpc::palette_distance::SpoDistanceMatrices for
  per-plane O(1) comparison. Methods: spo_distance(), subject_distance(),
  predicate_distance(), object_distance(). Build once from palette
  codebooks, compare via pre-computed 256×256 L1 tables.

  This is architecturally correct: ndarray = hardware (SIMD, palette,
  Base17); lance-graph = thinking (calls ndarray). No bit ops in contract.

TD-INT-8 — Schema validation on SPO commit:
  SpoBuilder::with_schema(Schema) + validate() + commit_validated()
  in lance-graph/graph/spo/builder.rs. Commit-time validation
  returns FailureTicket::missing_required on missing Required predicates.
  Existing SpoBuilder::commit() unchanged for backward compat.
  FailureTicket::missing_required constructor added to contract.

TD-INT-11 — neural-debug runtime registry populated:
  RuntimeRegistry with record(row, NeuronState), snapshot() → Vec,
  global accessor via registry()/init_registry(). NeuronState enum
  (Alive/Static/NaN). Re-exported from neural-debug lib.rs.
  10 tests passing.

Full workspace cargo check clean. 423 lib tests pass across all
affected crates.

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

crates/lance-graph-contract/src/grammar/free_energy.rs

@@ -227,6 +227,7 @@ mod tests {
             tekamolo: TekamoloSlots::default(),
             wechsel: vec![],
             coverage: 0.0,
+            missing_required: vec![],
         }
     }
 

crates/lance-graph-contract/src/grammar/role_keys.rs

@@ -78,47 +78,6 @@ impl RoleKey {
         self.slice_end - self.slice_start
     }
 
-    /// Hamming distance between two `Binary16K`-shaped fingerprints,
-    /// restricted to this role's slice `[slice_start..slice_end)`.
-    /// Bits outside the slice contribute zero. Used by the content
-    /// cascade for role-indexed similarity (TD-INT-5): "compare two
-    /// triples on the SUBJECT plane only" rather than over all 16384
-    /// bits. Binary-space analogue of unbind+cosine on a role.
-    pub fn hamming_in_slice(&self, fp_a: &[u64], fp_b: &[u64]) -> u32 {
-        debug_assert!(fp_a.len() == fp_b.len(), "fingerprint widths differ");
-        let mut total = 0u32;
-        let start_word = self.slice_start / 64;
-        let end_word = (self.slice_end + 63) / 64;
-        for w in start_word..end_word.min(fp_a.len()) {
-            let mut diff = fp_a[w] ^ fp_b[w];
-            if w == start_word {
-                let lo = self.slice_start % 64;
-                if lo > 0 {
-                    diff &= !((1u64 << lo) - 1);
-                }
-            }
-            if w + 1 == end_word {
-                let hi = self.slice_end % 64;
-                if hi > 0 {
-                    diff &= (1u64 << hi) - 1;
-                }
-            }
-            total += diff.count_ones();
-        }
-        total
-    }
-
-    /// Resonance score in `[0, 1]` for this role's slice. Higher = more similar.
-    /// `1 - hamming / slice_width`, density-agnostic.
-    pub fn resonance_in_slice(&self, fp_a: &[u64], fp_b: &[u64]) -> f32 {
-        let width = self.slice_width() as f32;
-        if width <= 0.0 {
-            return 1.0;
-        }
-        let h = self.hamming_in_slice(fp_a, fp_b) as f32;
-        (1.0 - h / width).clamp(0.0, 1.0)
-    }
-
     // NOTE: `bind/unbind/recovery_margin` methods removed in cleanup commit
     // `cd5c049...` (see CHANGELOG.md). Those operated on a hallucinated
     // `Vsa10k = [u64; 157]` bitpacked carrier with GF(2)/XOR algebra —
@@ -350,29 +309,6 @@ pub fn nars_inference_key(inf: NarsInference) -> &'static RoleKey {
 mod tests {
     use super::*;
 
-    #[test]
-    fn hamming_in_slice_zero_for_identical() {
-        let fp = vec![0xDEAD_BEEFu64; 256];
-        assert_eq!(SUBJECT_KEY.hamming_in_slice(&fp, &fp), 0);
-    }
-
-    #[test]
-    fn hamming_in_slice_only_counts_within_slice() {
-        let mut fp_a = vec![0u64; 256];
-        let mut fp_b = vec![0u64; 256];
-        fp_b[50] = 1u64 << 5; // outside SUBJECT slice — must not count
-        assert_eq!(SUBJECT_KEY.hamming_in_slice(&fp_a, &fp_b), 0);
-        fp_a[5] = 1u64 << 3;  // inside SUBJECT slice — must count
-        assert_eq!(SUBJECT_KEY.hamming_in_slice(&fp_a, &fp_b), 1);
-    }
-
-    #[test]
-    fn resonance_in_slice_full_match_is_one() {
-        let fp = vec![0xAAAA_5555u64; 256];
-        let r = SUBJECT_KEY.resonance_in_slice(&fp, &fp);
-        assert!((r - 1.0).abs() < 1e-6);
-    }
-
     /// Collect every (start, end, label) from every defined role key.
     fn all_slices() -> Vec<(usize, usize, &'static str)> {
         let mut v: Vec<(usize, usize, &'static str)> = Vec::new();

crates/lance-graph-contract/src/grammar/ticket.rs

@@ -150,6 +150,7 @@ mod tests {
             tekamolo: TekamoloSlots::default(),
             wechsel: vec![],
             coverage: 0.33,
+            missing_required: vec![],
         };
         assert!(t.needs_llm(0.9));
     }
@@ -160,4 +161,20 @@ mod tests {
         assert_eq!(c.plausible_count(), 2);
         assert!(!c.is_resolved(0.75));
     }
+
+    #[test]
+    fn missing_required_constructor_preserves_predicate_names() {
+        let t = FailureTicket::missing_required(vec!["customer_name", "tax_id"]);
+        let m: Vec<&'static str> = t.missing_predicates().collect();
+        assert_eq!(m, vec!["customer_name", "tax_id"]);
+        assert_eq!(t.recommended_next, NarsInference::Abduction);
+        assert_eq!(t.coverage, 0.0);
+        assert!(t.needs_llm(0.9), "schema miss must escalate");
+    }
+
+    #[test]
+    fn missing_required_constructor_empty_for_no_misses() {
+        let t = FailureTicket::missing_required(vec![]);
+        assert_eq!(t.missing_predicates().count(), 0);
+    }
 }

crates/lance-graph-planner/src/cache/convergence.rs

@@ -20,6 +20,52 @@
 
 use super::kv_bundle::HeadPrint;
 use super::nars_engine::{SpoHead, MASK_SPO, CausalEdge64};
+use ndarray::hpc::palette_distance::{Palette, DistanceMatrix, SpoDistanceMatrices};
+use ndarray::hpc::bgz17_bridge::SpoBase17;
+
+/// Per-plane palette distance context (TD-INT-5).
+///
+/// Wraps ndarray's `SpoDistanceMatrices` (pre-computed 256×256 per-plane
+/// L1 distance tables). All comparison algebra lives in ndarray; this
+/// struct is a session-scoped handle that the planner cache and cascade
+/// use to compare triplets on individual role planes (subject-only,
+/// predicate-only, etc.) without doing bit ops in lance-graph.
+///
+/// Build once from the palette codebooks; compare in O(1) per pair.
+pub struct PlaneDistance {
+    matrices: SpoDistanceMatrices,
+}
+
+impl PlaneDistance {
+    /// Build from three palettes (one per S/P/O plane).
+    pub fn build(s_pal: &Palette, p_pal: &Palette, o_pal: &Palette) -> Self {
+        Self { matrices: SpoDistanceMatrices::build(s_pal, p_pal, o_pal) }
+    }
+
+    /// Combined S+P+O distance. O(1): three table lookups.
+    #[inline]
+    pub fn spo_distance(&self, a: &SpoHead, b: &SpoHead) -> u32 {
+        self.matrices.spo_distance(a.s_idx, a.p_idx, a.o_idx, b.s_idx, b.p_idx, b.o_idx)
+    }
+
+    /// Subject-plane only distance. O(1): one table lookup.
+    #[inline]
+    pub fn subject_distance(&self, a: &SpoHead, b: &SpoHead) -> u16 {
+        self.matrices.subject.distance(a.s_idx, b.s_idx)
+    }
+
+    /// Predicate-plane only distance. O(1): one table lookup.
+    #[inline]
+    pub fn predicate_distance(&self, a: &SpoHead, b: &SpoHead) -> u16 {
+        self.matrices.predicate.distance(a.p_idx, b.p_idx)
+    }
+
+    /// Object-plane only distance. O(1): one table lookup.
+    #[inline]
+    pub fn object_distance(&self, a: &SpoHead, b: &SpoHead) -> u16 {
+        self.matrices.object.distance(a.o_idx, b.o_idx)
+    }
+}
 
 /// Convert an SPO triplet (as strings) into a HeadPrint fingerprint.
 ///
@@ -165,6 +211,34 @@ pub fn episodes_to_palette_layers(
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_plane_distance_subject_only() {
+        // Build a 256-entry palette (production size) from spread Base17 patterns
+        let patterns: Vec<ndarray::hpc::bgz17_bridge::Base17> = (0..256)
+            .map(|i| {
+                let mut b = ndarray::hpc::bgz17_bridge::Base17::zero();
+                b.dims[0] = (i as i16).wrapping_mul(127);
+                b.dims[1] = (i as i16).wrapping_mul(31);
+                b
+            })
+            .collect();
+        let pal = Palette::build(&patterns, 256, 1);
+        let pd = PlaneDistance::build(&pal, &pal, &pal);
+
+        // Same palette index → zero distance
+        let a = headprint_to_spo(&triplet_to_headprint("Alice", "knows", "Bob"), 0.9, 0.8);
+        assert_eq!(pd.subject_distance(&a, &a), 0);
+        assert_eq!(pd.spo_distance(&a, &a), 0);
+
+        // Different triplets → likely nonzero distance
+        let b = headprint_to_spo(&triplet_to_headprint("Zephyr", "loves", "Qux"), 0.9, 0.8);
+        let combined = pd.spo_distance(&a, &b);
+        let sub_only = pd.subject_distance(&a, &b);
+        // Subject-only ≤ combined (since combined adds P + O)
+        assert!(sub_only as u32 <= combined,
+            "subject-only {} should be <= combined {}", sub_only, combined);
+    }
+
     #[test]
     fn test_triplet_to_headprint() {
         let fp = triplet_to_headprint("Claude", "reasons_like", "Opus4.6");