split into workspace: poc-memory and poc-daemon subcrates

poc-daemon (notification routing, idle timer, IRC, Telegram) was already
fully self-contained with no imports from the poc-memory library. Now it's
a proper separate crate with its own Cargo.toml and capnp schema.

poc-memory retains the store, graph, search, neuro, knowledge, and the
jobkit-based memory maintenance daemon (daemon.rs).

Co-Authored-By: ProofOfConcept <poc@bcachefs.org>

poc-memory/src/bin/memory-search.rs

@@ -0,0 +1,185 @@
+// memory-search: combined hook for session context loading + ambient memory retrieval
+//
+// On first prompt per session: loads full memory context (identity, journal, etc.)
+// On subsequent prompts: searches memory for relevant entries
+// On post-compaction: reloads full context
+//
+// Reads JSON from stdin (Claude Code UserPromptSubmit hook format),
+// outputs results for injection into the conversation.
+
+use poc_memory::search;
+use poc_memory::store;
+use std::collections::HashSet;
+use std::fs;
+use std::io::{self, Read, Write};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{Duration, SystemTime};
+
+fn main() {
+    let mut input = String::new();
+    io::stdin().read_to_string(&mut input).unwrap_or_default();
+
+    let json: serde_json::Value = match serde_json::from_str(&input) {
+        Ok(v) => v,
+        Err(_) => return,
+    };
+
+    let prompt = json["prompt"].as_str().unwrap_or("");
+    let session_id = json["session_id"].as_str().unwrap_or("");
+
+    if prompt.is_empty() || session_id.is_empty() {
+        return;
+    }
+
+    let state_dir = PathBuf::from("/tmp/claude-memory-search");
+    fs::create_dir_all(&state_dir).ok();
+
+    // Detect post-compaction reload
+    let is_compaction = prompt.contains("continued from a previous conversation");
+
+    // First prompt or post-compaction: load full context
+    let cookie_path = state_dir.join(format!("cookie-{}", session_id));
+    let is_first = !cookie_path.exists();
+
+    if is_first || is_compaction {
+        // Create/touch the cookie
+        let cookie = if is_first {
+            let c = generate_cookie();
+            fs::write(&cookie_path, &c).ok();
+            c
+        } else {
+            fs::read_to_string(&cookie_path).unwrap_or_default().trim().to_string()
+        };
+
+        // Load full memory context
+        if let Ok(output) = Command::new("poc-memory").args(["load-context"]).output() {
+            if output.status.success() {
+                let ctx = String::from_utf8_lossy(&output.stdout);
+                if !ctx.trim().is_empty() {
+                    print!("{}", ctx);
+                }
+            }
+        }
+
+        // On first prompt, also bump lookup counter for the cookie
+        let _ = cookie; // used for tagging below
+    }
+
+    // Always do ambient search (skip on very short or system prompts)
+    let word_count = prompt.split_whitespace().count();
+    if word_count < 3 {
+        return;
+    }
+
+    for prefix in &["is AFK", "You're on your own", "IRC mention"] {
+        if prompt.starts_with(prefix) {
+            return;
+        }
+    }
+
+    let query = search::extract_query_terms(prompt, 3);
+    if query.is_empty() {
+        return;
+    }
+
+    let store = match store::Store::load() {
+        Ok(s) => s,
+        Err(_) => return,
+    };
+
+    let results = search::search(&query, &store);
+    if results.is_empty() {
+        return;
+    }
+
+    // Format results like poc-memory search output
+    let search_output = search::format_results(&results);
+
+    let cookie = fs::read_to_string(&cookie_path).unwrap_or_default().trim().to_string();
+    let seen = load_seen(&state_dir, session_id);
+
+    let mut result_output = String::new();
+    let mut count = 0;
+    let max_entries = 5;
+
+    for line in search_output.lines() {
+        if count >= max_entries { break; }
+
+        let trimmed = line.trim();
+        if trimmed.is_empty() { continue; }
+
+        if let Some(key) = extract_key_from_line(trimmed) {
+            if seen.contains(&key) { continue; }
+            mark_seen(&state_dir, session_id, &key);
+            result_output.push_str(line);
+            result_output.push('\n');
+            count += 1;
+        } else if count > 0 {
+            result_output.push_str(line);
+            result_output.push('\n');
+        }
+    }
+
+    if count == 0 { return; }
+
+    println!("Recalled memories [{}]:", cookie);
+    print!("{}", result_output);
+
+    // Clean up stale state files (opportunistic)
+    cleanup_stale_files(&state_dir, Duration::from_secs(86400));
+}
+
+
+fn extract_key_from_line(line: &str) -> Option<String> {
+    let after_bracket = line.find("] ")?;
+    let rest = &line[after_bracket + 2..];
+    let key_end = rest.find("  (c").unwrap_or(rest.len());
+    let key = rest[..key_end].trim();
+    if key.is_empty() || !key.contains('.') {
+        None
+    } else {
+        Some(key.to_string())
+    }
+}
+
+fn generate_cookie() -> String {
+    uuid::Uuid::new_v4().as_simple().to_string()[..12].to_string()
+}
+
+fn load_seen(dir: &Path, session_id: &str) -> HashSet<String> {
+    let path = dir.join(format!("seen-{}", session_id));
+    if path.exists() {
+        fs::read_to_string(path)
+            .unwrap_or_default()
+            .lines()
+            .map(|s| s.to_string())
+            .collect()
+    } else {
+        HashSet::new()
+    }
+}
+
+fn mark_seen(dir: &Path, session_id: &str, key: &str) {
+    let path = dir.join(format!("seen-{}", session_id));
+    if let Ok(mut f) = fs::OpenOptions::new().create(true).append(true).open(path) {
+        writeln!(f, "{}", key).ok();
+    }
+}
+
+fn cleanup_stale_files(dir: &Path, max_age: Duration) {
+    let entries = match fs::read_dir(dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+    let cutoff = SystemTime::now() - max_age;
+    for entry in entries.flatten() {
+        if let Ok(meta) = entry.metadata() {
+            if let Ok(modified) = meta.modified() {
+                if modified < cutoff {
+                    fs::remove_file(entry.path()).ok();
+                }
+            }
+        }
+    }
+}