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();
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,171 @@
+// Unified Claude Code hook.
+//
+// Single binary handling all hook events:
+//   UserPromptSubmit — signal daemon, check notifications, check context
+//   PostToolUse      — check context (rate-limited)
+//   Stop             — signal daemon response
+//
+// Replaces: record-user-message-time.sh, check-notifications.sh,
+//           check-context-usage.sh, notify-done.sh, context-check
+
+use serde_json::Value;
+use std::fs;
+use std::io::{self, Read};
+use std::path::PathBuf;
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+const CONTEXT_THRESHOLD: u64 = 130_000;
+const RATE_LIMIT_SECS: u64 = 60;
+const SOCK_PATH: &str = ".claude/hooks/idle-timer.sock";
+
+fn now_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs()
+}
+
+fn home() -> PathBuf {
+    PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/root".into()))
+}
+
+fn daemon_cmd(args: &[&str]) {
+    Command::new("poc-daemon")
+        .args(args)
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()
+        .ok();
+}
+
+fn daemon_available() -> bool {
+    home().join(SOCK_PATH).exists()
+}
+
+fn signal_user() {
+    let pane = std::env::var("TMUX_PANE").unwrap_or_default();
+    if pane.is_empty() {
+        daemon_cmd(&["user"]);
+    } else {
+        daemon_cmd(&["user", &pane]);
+    }
+}
+
+fn signal_response() {
+    daemon_cmd(&["response"]);
+}
+
+fn check_notifications() {
+    if !daemon_available() {
+        return;
+    }
+    let output = Command::new("poc-daemon")
+        .arg("notifications")
+        .output()
+        .ok();
+    if let Some(out) = output {
+        let text = String::from_utf8_lossy(&out.stdout);
+        if !text.trim().is_empty() {
+            println!("You have pending notifications:");
+            print!("{text}");
+        }
+    }
+}
+
+fn check_context(transcript: &PathBuf, rate_limit: bool) {
+    if rate_limit {
+        let rate_file = PathBuf::from("/tmp/claude-context-check-last");
+        if let Ok(s) = fs::read_to_string(&rate_file) {
+            if let Ok(last) = s.trim().parse::<u64>() {
+                if now_secs() - last < RATE_LIMIT_SECS {
+                    return;
+                }
+            }
+        }
+        let _ = fs::write(&rate_file, now_secs().to_string());
+    }
+
+    if !transcript.exists() {
+        return;
+    }
+
+    let content = match fs::read_to_string(transcript) {
+        Ok(c) => c,
+        Err(_) => return,
+    };
+
+    let mut usage: u64 = 0;
+    for line in content.lines().rev().take(500) {
+        if !line.contains("cache_read_input_tokens") {
+            continue;
+        }
+        if let Ok(v) = serde_json::from_str::<Value>(line) {
+            let u = &v["message"]["usage"];
+            let input_tokens = u["input_tokens"].as_u64().unwrap_or(0);
+            let cache_creation = u["cache_creation_input_tokens"].as_u64().unwrap_or(0);
+            let cache_read = u["cache_read_input_tokens"].as_u64().unwrap_or(0);
+            usage = input_tokens + cache_creation + cache_read;
+            break;
+        }
+    }
+
+    if usage > CONTEXT_THRESHOLD {
+        print!(
+            "\
+CONTEXT WARNING: Compaction approaching ({usage} tokens). Write a journal entry NOW.
+
+Use `poc-memory journal-write \"entry text\"` to save a dated entry covering:
+- What you're working on and current state (done / in progress / blocked)
+- Key things learned this session (patterns, debugging insights)
+- Anything half-finished that needs pickup
+
+Keep it narrative, not a task log."
+        );
+    }
+}
+
+fn main() {
+    let mut input = String::new();
+    io::stdin().read_to_string(&mut input).ok();
+
+    let hook: Value = match serde_json::from_str(&input) {
+        Ok(v) => v,
+        Err(_) => return,
+    };
+
+    let hook_type = hook["hook_event_name"].as_str().unwrap_or("unknown");
+    let transcript = hook["transcript_path"]
+        .as_str()
+        .filter(|p| !p.is_empty())
+        .map(PathBuf::from);
+
+    // Daemon agent calls set POC_AGENT=1 — skip all signaling.
+    // Without this, the daemon's claude -p calls trigger hooks that
+    // signal "user active", keeping the idle timer permanently reset.
+    if std::env::var("POC_AGENT").is_ok() {
+        return;
+    }
+
+    match hook_type {
+        "UserPromptSubmit" => {
+            signal_user();
+            check_notifications();
+            if let Some(ref t) = transcript {
+                check_context(t, false);
+            }
+        }
+        "PostToolUse" => {
+            if let Some(ref t) = transcript {
+                check_context(t, true);
+            }
+        }
+        "Stop" => {
+            let stop_hook_active = hook["stop_hook_active"].as_bool().unwrap_or(false);
+            if !stop_hook_active {
+                signal_response();
+            }
+        }
+        _ => {}
+    }
+}