Fix L1 WAL write-behind + L5 FINGERPRINT constant mismatch

L1 (CRITICAL): Reorder on_write() and on_delete() in hardening.rs so
WAL append happens BEFORE in-memory LRU/TTL mutations. Previously a
crash between memory update and WAL would lose data silently.

L5 (MEDIUM): Make FINGERPRINT_U64 in lib.rs an alias for
FINGERPRINT_WORDS from bind_space.rs instead of independent constant.
Also replace hardcoded 256 in cog_redis.rs with FINGERPRINT_U64.

L2, L3, L4 verified already fixed in prior sessions.

https://claude.ai/code/session_0152b2NJYnjCJjvMAmgsTx3p

Author: claude

src/lib.rs

@@ -276,5 +276,7 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 /// Fingerprint dimensions (16K = 2^14, exact u64 alignment, no partial word)
 pub const FINGERPRINT_BITS: usize = 16_384;
-pub const FINGERPRINT_U64: usize = 256; // 16384/64, exact
+/// Alias for `FINGERPRINT_WORDS` — kept for backwards compatibility.
+/// Prefer `storage::bind_space::FINGERPRINT_WORDS` for new code.
+pub const FINGERPRINT_U64: usize = crate::storage::bind_space::FINGERPRINT_WORDS;
 pub const FINGERPRINT_BYTES: usize = 2048; // 256×8

src/storage/cog_redis.rs

@@ -2744,7 +2744,7 @@ fn fp_to_words(fp: &Fingerprint) -> [u64; 256] {
 fn words_to_fp(words: &[u64; 256]) -> Fingerprint {
     use crate::FINGERPRINT_U64;
     let mut data = [0u64; FINGERPRINT_U64];
-    data[..256].copy_from_slice(words);
+    data[..FINGERPRINT_U64].copy_from_slice(words);
     Fingerprint::from_raw(data)
 }
 

src/storage/hardening.rs

@@ -746,6 +746,21 @@ impl HardenedBindSpace {
     ) -> Vec<u16> {
         self.metrics.writes.fetch_add(1, Ordering::Relaxed);
 
+        // WAL FIRST — write-ahead, not write-behind.
+        // If we crash after WAL but before memory update, replay recovers.
+        // If we crash after memory update but before WAL, data is lost.
+        if let Some(ref wal) = self.wal {
+            if let Ok(mut wal) = wal.lock() {
+                let entry = WalEntry::Write {
+                    addr: addr.0,
+                    fingerprint: *fingerprint,
+                    label: label.map(|s| s.to_string()),
+                };
+                let _ = wal.append(&entry);
+                self.metrics.wal_writes.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+
         let prefix = addr.prefix();
         let mut to_evict = Vec::new();
 
@@ -784,26 +799,22 @@ impl HardenedBindSpace {
             }
         }
 
-        // WAL
-        if let Some(ref wal) = self.wal {
-            if let Ok(mut wal) = wal.lock() {
-                let entry = WalEntry::Write {
-                    addr: addr.0,
-                    fingerprint: *fingerprint,
-                    label: label.map(|s| s.to_string()),
-                };
-                let _ = wal.append(&entry);
-                self.metrics.wal_writes.fetch_add(1, Ordering::Relaxed);
-            }
-        }
-
         to_evict
     }
 
     /// Record a delete
     pub fn on_delete(&self, addr: Addr) {
         self.metrics.deletes.fetch_add(1, Ordering::Relaxed);
 
+        // WAL FIRST — durable record before in-memory mutation
+        if let Some(ref wal) = self.wal {
+            if let Ok(mut wal) = wal.lock() {
+                let entry = WalEntry::Delete { addr: addr.0 };
+                let _ = wal.append(&entry);
+                self.metrics.wal_writes.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+
         let prefix = addr.prefix();
         if prefix >= PREFIX_FLUID_START && prefix <= PREFIX_FLUID_END {
             if let Ok(mut lru) = self.fluid_lru.lock() {
@@ -817,15 +828,6 @@ impl HardenedBindSpace {
                 lru.remove(addr.0);
             }
         }
-
-        // WAL
-        if let Some(ref wal) = self.wal {
-            if let Ok(mut wal) = wal.lock() {
-                let entry = WalEntry::Delete { addr: addr.0 };
-                let _ = wal.append(&entry);
-                self.metrics.wal_writes.fetch_add(1, Ordering::Relaxed);
-            }
-        }
     }
 
     /// Record a link