restructure: hippocampus/ for memory, subconscious/ for agents

hippocampus/ — memory storage, retrieval, and consolidation:
  store, graph, query, similarity, spectral, neuro, counters,
  config, transcript, memory_search, lookups, cursor, migrate

subconscious/ — autonomous agents that process without being asked:
  reflect, surface, consolidate, digest, audit, etc.

All existing crate::X paths preserved via re-exports in lib.rs.

Co-Authored-By: Proof of Concept <poc@bcachefs.org>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

src/hippocampus/lookups.rs

@@ -0,0 +1,204 @@
+// Daily lookup counters — mmap'd open-addressing hash table.
+//
+// Records which memory keys are retrieved each day. The knowledge loop
+// uses this to focus extraction on actively-used graph neighborhoods,
+// like hippocampal replay preferentially consolidating recent experience.
+//
+// Format: 16-byte header + 4096 entries of (u64 hash, u32 count).
+// Total: ~49KB per day. Fast path: hash key → probe → bump counter.
+// No store loading required.
+
+use std::fs;
+use std::path::PathBuf;
+
+use crate::util::memory_subdir;
+
+const MAGIC: [u8; 4] = *b"LKUP";
+const VERSION: u32 = 1;
+const CAPACITY: u32 = 4096;
+const HEADER_SIZE: usize = 16;
+const ENTRY_SIZE: usize = 12; // u64 hash + u32 count
+const FILE_SIZE: usize = HEADER_SIZE + CAPACITY as usize * ENTRY_SIZE;
+
+// FNV-1a hash — simple, fast, no dependencies
+fn fnv1a(key: &str) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for b in key.as_bytes() {
+        h ^= *b as u64;
+        h = h.wrapping_mul(0x100000001b3);
+    }
+    h
+}
+
+fn daily_path(date: &str) -> Result<PathBuf, String> {
+    let dir = memory_subdir("lookups")?;
+    Ok(dir.join(format!("{}.bin", date)))
+}
+
+fn today() -> String {
+    chrono::Local::now().format("%Y-%m-%d").to_string()
+}
+
+/// Read or create the daily file, returning its contents as a mutable Vec.
+fn load_file(date: &str) -> Result<Vec<u8>, String> {
+    let path = daily_path(date)?;
+
+    if path.exists() {
+        let data = fs::read(&path)
+            .map_err(|e| format!("read {}: {}", path.display(), e))?;
+        if data.len() == FILE_SIZE && data[0..4] == MAGIC {
+            return Ok(data);
+        }
+        // Corrupt or wrong size — reinitialize
+    }
+
+    // Create fresh file
+    let mut buf = vec![0u8; FILE_SIZE];
+    buf[0..4].copy_from_slice(&MAGIC);
+    buf[4..8].copy_from_slice(&VERSION.to_le_bytes());
+    buf[8..12].copy_from_slice(&CAPACITY.to_le_bytes());
+    // count = 0 (already zero)
+    Ok(buf)
+}
+
+fn write_file(date: &str, data: &[u8]) -> Result<(), String> {
+    let path = daily_path(date)?;
+    fs::write(&path, data)
+        .map_err(|e| format!("write {}: {}", path.display(), e))
+}
+
+fn entry_offset(slot: usize) -> usize {
+    HEADER_SIZE + slot * ENTRY_SIZE
+}
+
+fn read_entry(data: &[u8], slot: usize) -> (u64, u32) {
+    let off = entry_offset(slot);
+    let hash = u64::from_le_bytes(data[off..off + 8].try_into().unwrap());
+    let count = u32::from_le_bytes(data[off + 8..off + 12].try_into().unwrap());
+    (hash, count)
+}
+
+fn write_entry(data: &mut [u8], slot: usize, hash: u64, count: u32) {
+    let off = entry_offset(slot);
+    data[off..off + 8].copy_from_slice(&hash.to_le_bytes());
+    data[off + 8..off + 12].copy_from_slice(&count.to_le_bytes());
+}
+
+fn read_count(data: &[u8]) -> u32 {
+    u32::from_le_bytes(data[12..16].try_into().unwrap())
+}
+
+fn write_count(data: &mut [u8], count: u32) {
+    data[12..16].copy_from_slice(&count.to_le_bytes());
+}
+
+/// Bump the counter for a key. Fast path — no store needed.
+pub fn bump(key: &str) -> Result<(), String> {
+    let date = today();
+    let mut data = load_file(&date)?;
+    let hash = fnv1a(key);
+    let cap = CAPACITY as usize;
+
+    let mut slot = (hash as usize) % cap;
+    for _ in 0..cap {
+        let (h, c) = read_entry(&data, slot);
+        if h == hash {
+            // Existing entry — bump
+            write_entry(&mut data, slot, hash, c + 1);
+            write_file(&date, &data)?;
+            return Ok(());
+        }
+        if h == 0 && c == 0 {
+            // Empty slot — new entry
+            write_entry(&mut data, slot, hash, 1);
+            let c = read_count(&data);
+            write_count(&mut data, c + 1);
+            write_file(&date, &data)?;
+            return Ok(());
+        }
+        slot = (slot + 1) % cap;
+    }
+
+    // Table full (shouldn't happen with 4096 slots)
+    Err("lookup table full".into())
+}
+
+/// Bump counters for multiple keys at once (single file read/write).
+pub fn bump_many(keys: &[&str]) -> Result<(), String> {
+    if keys.is_empty() { return Ok(()); }
+
+    let date = today();
+    let mut data = load_file(&date)?;
+    let cap = CAPACITY as usize;
+    let mut used = read_count(&data);
+
+    for key in keys {
+        let hash = fnv1a(key);
+        let mut slot = (hash as usize) % cap;
+        let mut found = false;
+
+        for _ in 0..cap {
+            let (h, c) = read_entry(&data, slot);
+            if h == hash {
+                write_entry(&mut data, slot, hash, c + 1);
+                found = true;
+                break;
+            }
+            if h == 0 && c == 0 {
+                write_entry(&mut data, slot, hash, 1);
+                used += 1;
+                found = true;
+                break;
+            }
+            slot = (slot + 1) % cap;
+        }
+        if !found {
+            // Table full — stop, don't lose what we have
+            break;
+        }
+    }
+
+    write_count(&mut data, used);
+    write_file(&date, &data)
+}
+
+/// Dump all lookups for a date as (hash, count) pairs, sorted by count descending.
+pub fn dump_raw(date: &str) -> Result<Vec<(u64, u32)>, String> {
+    let data = load_file(date)?;
+    let mut entries = Vec::new();
+
+    for slot in 0..CAPACITY as usize {
+        let (hash, count) = read_entry(&data, slot);
+        if hash != 0 || count != 0 {
+            entries.push((hash, count));
+        }
+    }
+
+    entries.sort_by(|a, b| b.1.cmp(&a.1));
+    Ok(entries)
+}
+
+/// Resolve hashes to keys by scanning the store. Returns (key, count) pairs.
+pub fn dump_resolved(date: &str, keys: &[String]) -> Result<Vec<(String, u32)>, String> {
+    let raw = dump_raw(date)?;
+
+    // Build hash → key map from known keys
+    let hash_map: std::collections::HashMap<u64, &str> = keys.iter()
+        .map(|k| (fnv1a(k), k.as_str()))
+        .collect();
+
+    let mut resolved = Vec::new();
+    for (hash, count) in raw {
+        let key = hash_map.get(&hash)
+            .map(|k| k.to_string())
+            .unwrap_or_else(|| format!("#{:016x}", hash));
+        resolved.push((key, count));
+    }
+
+    Ok(resolved)
+}
+
+/// Hash a key (exposed for testing/external use).
+pub fn hash_key(key: &str) -> u64 {
+    fnv1a(key)
+}