fix: revert incorrect bind_space.rs changes — ClamPath belongs on CogRecord8K, not BindNode

Removes clam_merkle field, verify_lineage(), Epoch, and stamp methods from BindNode.
ClamPath + MerkleRoot is already correctly implemented in src/spo/clam_path.rs via
ClamPathExt trait on CogRecord8K.index.words[0]. BindNode is a lightweight DTO —
enriching it with integrity verification violated the Three-Layer Principle
(BINDSPACE_UNIFICATION.md).

https://claude.ai/code/session_013JU8MRtxRRTtuc5217r6s5

Author: claude

src/storage/bind_space.rs

@@ -47,7 +47,6 @@ use std::collections::HashMap;
 
 use crate::container::adjacency::PackedDn;
 use crate::container::{CONTAINER_WORDS, Container, MetaView, MetaViewMut};
-use crate::spo::clam_path::{ClamPath, MerkleRoot};
 
 // =============================================================================
 // ADDRESS CONSTANTS (8-bit prefix : 8-bit slot)
@@ -359,10 +358,6 @@ pub struct BindNode {
     /// Epoch millis when this node was last written/modified.
     /// Used for age-based hot→cold tier flushing to Lance.
     pub updated_at: u64,
-    /// ClamPath(24 bits) + MerkleRoot(40 bits) packed into u64.
-    /// Stamped during write_dn_node()/write_dn_path().
-    /// See ClamPath::pack_with_merkle() / unpack_with_merkle().
-    pub clam_merkle: u64,
 }
 
 impl BindNode {
@@ -383,7 +378,6 @@ impl BindNode {
             sigma: 0,
             is_spine: false,
             updated_at: now,
-            clam_merkle: 0,
         }
     }
 
@@ -780,54 +774,6 @@ impl DirtyBits {
     }
 }
 
-// =============================================================================
-// INTEGRITY RESULT
-// =============================================================================
-
-/// Result of a lineage integrity check.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum IntegrityResult {
-    /// All parent-child MerkleRoots are consistent.
-    Consistent,
-    /// A node in the lineage chain diverged (roots inconsistent).
-    Diverged { at: Addr },
-    /// A node in the lineage chain was not found.
-    Missing { at: Addr },
-}
-
-// =============================================================================
-// EPOCH: Dirty bitset snapshot for change detection
-// =============================================================================
-
-/// 8 KB dirty bitset snapshot. Flat array, same shape as DirtyBits.
-/// XOR two epochs to find what changed. POPCNT = how many. iter set bits = which.
-#[derive(Clone)]
-pub struct Epoch {
-    pub bits: [u64; TOTAL_ADDRESSES / 64],
-    pub timestamp_ms: u64,
-}
-
-impl Epoch {
-    /// Find addresses that changed between two epochs.
-    /// XOR the bitsets, iterate set bits = changed addresses.
-    pub fn changed_between<'a>(a: &'a Epoch, b: &'a Epoch) -> impl Iterator<Item = Addr> + 'a {
-        a.bits.iter().zip(b.bits.iter()).enumerate().flat_map(|(wi, (&wa, &wb))| {
-            let xor = wa ^ wb;
-            let base = (wi * 64) as u16;
-            (0..64u16)
-                .filter(move |&bit| xor & (1u64 << bit) != 0)
-                .map(move |bit| Addr(base + bit))
-        })
-    }
-
-    /// Count of changed addresses between two epochs.
-    pub fn change_count(a: &Epoch, b: &Epoch) -> u32 {
-        a.bits.iter().zip(b.bits.iter())
-            .map(|(&wa, &wb)| (wa ^ wb).count_ones())
-            .sum()
-    }
-}
-
 // =============================================================================
 // BIND SPACE - The Universal DTO (Array-based storage)
 // =============================================================================
@@ -1468,16 +1414,11 @@ impl BindSpace {
             .unwrap_or(0);
 
         let addr = self.write(fingerprint);
-
-        // Stamp ClamPath + MerkleRoot. ClamPath is ROOT initially.
-        let clam_merkle = Self::derive_clam_merkle(&fingerprint);
-
         if let Some(node) = self.read_mut(addr) {
             node.label = Some(label.to_string());
             node.parent = parent;
             node.depth = depth;
             node.rung = rung;
-            node.clam_merkle = clam_merkle;
         }
 
         // Auto-link PARENT_OF edge
@@ -1542,16 +1483,11 @@ impl BindSpace {
 
                 // Write at computed address
                 self.write_at(addr, fp);
-
-                // Stamp ClamPath + MerkleRoot
-                let clam_merkle = Self::derive_clam_merkle(&fp);
-
                 if let Some(node) = self.read_mut(addr) {
                     node.label = Some(format!("bindspace://{}", current_path));
                     node.parent = current_parent;
                     node.depth = i as u8;
                     node.rung = rung;
-                    node.clam_merkle = clam_merkle;
                 }
 
                 // Link to parent
@@ -1909,84 +1845,6 @@ impl BindSpace {
         self.dirty.clear();
     }
 
-    // =========================================================================
-    // INTEGRITY: ClamPath + MerkleRoot
-    // =========================================================================
-
-    /// Derive ClamPath::ROOT + MerkleRoot from a fingerprint array.
-    /// blake3 hash of the first 2048 bytes, truncated to 40 bits.
-    fn derive_clam_merkle(fingerprint: &[u64; FINGERPRINT_WORDS]) -> u64 {
-        // Reinterpret u64 words as bytes (safe: same representation)
-        let fp_bytes: &[u8] = unsafe {
-            std::slice::from_raw_parts(
-                fingerprint.as_ptr() as *const u8,
-                fingerprint.len() * 8,
-            )
-        };
-        // Use first 2048 bytes for MerkleRoot
-        let fp_2k: &[u8; 2048] = fp_bytes[..2048].try_into().unwrap();
-        let merkle = MerkleRoot::from_fingerprint(fp_2k);
-        ClamPath::ROOT.pack_with_merkle(merkle)
-    }
-
-    /// Read ClamPath + MerkleRoot from a node's clam_merkle field. O(1).
-    #[inline]
-    pub fn clam_merkle(&self, addr: Addr) -> Option<(ClamPath, MerkleRoot)> {
-        self.read(addr).map(|n| ClamPath::unpack_with_merkle(n.clam_merkle))
-    }
-
-    /// Update ClamPath for a node (e.g., after CLAM tree rebuild).
-    /// Preserves existing MerkleRoot.
-    pub fn set_clam_path(&mut self, addr: Addr, path: ClamPath) {
-        if let Some(node) = self.read_mut(addr) {
-            let (_, root) = ClamPath::unpack_with_merkle(node.clam_merkle);
-            node.clam_merkle = path.pack_with_merkle(root);
-        }
-    }
-
-    /// Verify integrity from addr up to root via parent chain.
-    /// Each step: read clam_merkle at known address (O(1)), check non-zero root.
-    /// Full XOR-of-children verification requires knowing all children;
-    /// this walks the lineage chain and checks consistency.
-    pub fn verify_lineage(&self, addr: Addr) -> IntegrityResult {
-        let child_node = match self.read(addr) {
-            Some(n) => n,
-            None => return IntegrityResult::Missing { at: addr },
-        };
-        let (_, child_root) = ClamPath::unpack_with_merkle(child_node.clam_merkle);
-        let _ = child_root; // used for chain start
-
-        // Walk parent chain — each step is O(1) array index + compare.
-        for parent_addr in self.ancestors(addr) {
-            let parent_node = match self.read(parent_addr) {
-                Some(n) => n,
-                None => return IntegrityResult::Missing { at: parent_addr },
-            };
-            let (_, parent_root) = ClamPath::unpack_with_merkle(parent_node.clam_merkle);
-
-            // Skip uninitialized nodes (not yet stamped)
-            if parent_root.is_zero() {
-                continue;
-            }
-        }
-        IntegrityResult::Consistent
-    }
-
-    // =========================================================================
-    // EPOCH: DirtyBits XOR for change detection
-    // =========================================================================
-
-    /// Snapshot current dirty bits as an Epoch (8 KB copy).
-    pub fn snapshot_dirty(&self) -> Epoch {
-        let now = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_millis() as u64;
-        let mut bits = [0u64; TOTAL_ADDRESSES / 64];
-        bits.copy_from_slice(&self.dirty.bits);
-        Epoch { bits, timestamp_ms: now }
-    }
-
     // =========================================================================
     // PARALLEL BULK OPERATIONS (split_at_mut / parallel_into_slices)
     // =========================================================================
@@ -2909,93 +2767,4 @@ mod tests {
         let csr = space.csr.as_ref().unwrap();
         assert!(csr.memory_bytes() < 300_000); // Should be ~260KB vs >1.5MB traditional
     }
-
-    // =========================================================================
-    // ClamPath + MerkleRoot stamp tests
-    // =========================================================================
-
-    #[test]
-    fn test_clam_merkle_stamp_on_write_dn() {
-        let mut space = BindSpace::new();
-        let fp = [0xDEAD_BEEF_u64; FINGERPRINT_WORDS];
-
-        let addr = space.write_dn_path("agent:A:soul:identity", fp, 5);
-
-        // clam_merkle should be stamped (non-zero)
-        let node = space.read(addr).unwrap();
-        assert_ne!(node.clam_merkle, 0, "clam_merkle should be stamped on write_dn_path");
-
-        // Unpack and verify
-        let (path, root) = ClamPath::unpack_with_merkle(node.clam_merkle);
-        assert!(!root.is_zero(), "MerkleRoot should be non-zero for non-zero fingerprint");
-        assert_eq!(path, ClamPath::ROOT, "Initial ClamPath should be ROOT");
-    }
-
-    #[test]
-    fn test_clam_merkle_round_trip() {
-        let mut space = BindSpace::new();
-        let fp = [42u64; FINGERPRINT_WORDS];
-
-        let addr = space.write_dn_path("agent:A:test", fp, 1);
-        let (_path, root) = space.clam_merkle(addr).unwrap();
-
-        // Set a custom ClamPath (depth=3 means top 3 bits valid: 0xE000)
-        let custom_path = ClamPath { bits: 0xE000, depth: 3 };
-        space.set_clam_path(addr, custom_path);
-
-        let (path2, root2) = space.clam_merkle(addr).unwrap();
-        assert_eq!(path2.bits, custom_path.bits, "ClamPath bits should update");
-        assert_eq!(path2.depth, custom_path.depth, "ClamPath depth should update");
-        assert_eq!(root2, root, "MerkleRoot should be preserved across set_clam_path");
-    }
-
-    // =========================================================================
-    // Integrity verification tests
-    // =========================================================================
-
-    #[test]
-    fn test_integrity_verify_lineage_consistent() {
-        let mut space = BindSpace::new();
-        let fp = [7u64; FINGERPRINT_WORDS];
-
-        let leaf = space.write_dn_path("agent:A:soul:identity", fp, 5);
-
-        // verify_lineage should report consistent (all roots are stamped)
-        let result = space.verify_lineage(leaf);
-        assert_eq!(result, IntegrityResult::Consistent);
-    }
-
-    #[test]
-    fn test_integrity_verify_missing() {
-        let space = BindSpace::new();
-        // Non-existent address
-        let result = space.verify_lineage(Addr(0xFFFF));
-        assert_eq!(result, IntegrityResult::Missing { at: Addr(0xFFFF) });
-    }
-
-    // =========================================================================
-    // Epoch tests
-    // =========================================================================
-
-    #[test]
-    fn test_epoch_snapshot_and_diff() {
-        let mut space = BindSpace::new();
-        let fp1 = [1u64; FINGERPRINT_WORDS];
-        let fp2 = [2u64; FINGERPRINT_WORDS];
-
-        // Take initial epoch
-        let epoch1 = space.snapshot_dirty();
-
-        // Write some data
-        space.write_dn_path("agent:A:test1", fp1, 1);
-        space.write_dn_path("agent:B:test2", fp2, 1);
-
-        // Take second epoch
-        let epoch2 = space.snapshot_dirty();
-
-        // Should detect changes
-        let changed: Vec<Addr> = Epoch::changed_between(&epoch1, &epoch2).collect();
-        assert!(!changed.is_empty(), "Should detect dirty addresses");
-        assert!(Epoch::change_count(&epoch1, &epoch2) > 0);
-    }
 }