refactor: eliminate date shell-outs, move logic to Store methods

- Replace all 5 `Command::new("date")` calls across 4 files with
  pure Rust time formatting via libc localtime_r
- Add format_date/format_datetime/format_datetime_space helpers to
  capnp_store
- Move import_file, find_journal_node, export_to_markdown, render_file,
  file_sections into Store methods where they belong
- Fix find_current_transcript to search all project dirs instead of
  hardcoding bcachefs-tools path
- Fix double-reference .clone() warnings in cmd_trace
- Fix unused variable warning in neuro.rs

main.rs: 1290 → 1137 lines, zero warnings.

src/capnp_store.rs

@@ -23,7 +23,7 @@ use std::fs;
 use std::io::{BufReader, BufWriter, Write as IoWrite};
 use std::os::unix::io::AsRawFd;
 use std::path::{Path, PathBuf};
-use std::process::Command;
+
 use std::time::{SystemTime, UNIX_EPOCH};
 
 // Data dir: ~/.claude/memory/
@@ -62,17 +62,50 @@ impl StoreLock {
     // Lock released automatically when _file is dropped (flock semantics)
 }
 
-fn now_epoch() -> f64 {
+pub fn now_epoch() -> f64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .unwrap()
         .as_secs_f64()
 }
 
-fn today() -> String {
-    let out = Command::new("date").arg("+%Y-%m-%d")
-        .output().expect("date command failed");
-    String::from_utf8_lossy(&out.stdout).trim().to_string()
+/// Convert epoch seconds to broken-down local time components.
+/// Returns (year, month, day, hour, minute, second).
+pub fn epoch_to_local(epoch: f64) -> (i32, u32, u32, u32, u32, u32) {
+    // Use libc localtime_r for timezone-correct conversion
+    let secs = epoch as libc::time_t;
+    let mut tm: libc::tm = unsafe { std::mem::zeroed() };
+    unsafe { libc::localtime_r(&secs, &mut tm) };
+    (
+        tm.tm_year + 1900,
+        (tm.tm_mon + 1) as u32,
+        tm.tm_mday as u32,
+        tm.tm_hour as u32,
+        tm.tm_min as u32,
+        tm.tm_sec as u32,
+    )
+}
+
+/// Format epoch as "YYYY-MM-DD"
+pub fn format_date(epoch: f64) -> String {
+    let (y, m, d, _, _, _) = epoch_to_local(epoch);
+    format!("{:04}-{:02}-{:02}", y, m, d)
+}
+
+/// Format epoch as "YYYY-MM-DDTHH:MM"
+pub fn format_datetime(epoch: f64) -> String {
+    let (y, m, d, h, min, _) = epoch_to_local(epoch);
+    format!("{:04}-{:02}-{:02}T{:02}:{:02}", y, m, d, h, min)
+}
+
+/// Format epoch as "YYYY-MM-DD HH:MM"
+pub fn format_datetime_space(epoch: f64) -> String {
+    let (y, m, d, h, min, _) = epoch_to_local(epoch);
+    format!("{:04}-{:02}-{:02} {:02}:{:02}", y, m, d, h, min)
+}
+
+pub fn today() -> String {
+    format_date(now_epoch())
 }
 
 // In-memory node representation
@@ -908,6 +941,165 @@ impl Store {
             node.schema_fit = fits.get(key).copied();
         }
     }
+
+    /// Import a markdown file into the store, parsing it into nodes.
+    /// Returns (new_count, updated_count).
+    pub fn import_file(&mut self, path: &Path) -> Result<(usize, usize), String> {
+        let filename = path.file_name().unwrap().to_string_lossy().to_string();
+        let content = fs::read_to_string(path)
+            .map_err(|e| format!("read {}: {}", path.display(), e))?;
+
+        let units = parse_units(&filename, &content);
+        let mut new_nodes = Vec::new();
+        let mut updated_nodes = Vec::new();
+
+        let node_type = if filename.starts_with("daily-") {
+            NodeType::EpisodicDaily
+        } else if filename.starts_with("weekly-") {
+            NodeType::EpisodicWeekly
+        } else if filename == "journal.md" {
+            NodeType::EpisodicSession
+        } else {
+            NodeType::Semantic
+        };
+
+        for (pos, unit) in units.iter().enumerate() {
+            if let Some(existing) = self.nodes.get(&unit.key) {
+                let pos_changed = existing.position != pos as u32;
+                if existing.content != unit.content || pos_changed {
+                    let mut node = existing.clone();
+                    node.content = unit.content.clone();
+                    node.position = pos as u32;
+                    node.version += 1;
+                    println!("  U {}", unit.key);
+                    updated_nodes.push(node);
+                }
+            } else {
+                let mut node = Store::new_node(&unit.key, &unit.content);
+                node.node_type = node_type;
+                node.position = pos as u32;
+                println!("  + {}", unit.key);
+                new_nodes.push(node);
+            }
+        }
+
+        if !new_nodes.is_empty() {
+            self.append_nodes(&new_nodes)?;
+            for node in &new_nodes {
+                self.uuid_to_key.insert(node.uuid, node.key.clone());
+                self.nodes.insert(node.key.clone(), node.clone());
+            }
+        }
+        if !updated_nodes.is_empty() {
+            self.append_nodes(&updated_nodes)?;
+            for node in &updated_nodes {
+                self.nodes.insert(node.key.clone(), node.clone());
+            }
+        }
+
+        Ok((new_nodes.len(), updated_nodes.len()))
+    }
+
+    /// Gather all sections for a file key, sorted by position.
+    /// Returns None if no nodes found.
+    pub fn file_sections(&self, file_key: &str) -> Option<Vec<&Node>> {
+        let prefix = format!("{}#", file_key);
+        let mut sections: Vec<_> = self.nodes.values()
+            .filter(|n| n.key == file_key || n.key.starts_with(&prefix))
+            .collect();
+        if sections.is_empty() {
+            return None;
+        }
+        sections.sort_by_key(|n| n.position);
+        Some(sections)
+    }
+
+    /// Render a file key as plain content (no mem markers).
+    pub fn render_file(&self, file_key: &str) -> Option<String> {
+        let sections = self.file_sections(file_key)?;
+        let mut output = String::new();
+        for node in &sections {
+            output.push_str(&node.content);
+            if !node.content.ends_with('\n') {
+                output.push('\n');
+            }
+            output.push('\n');
+        }
+        Some(output.trim_end().to_string())
+    }
+
+    /// Render a file key (and all its section nodes) back to markdown
+    /// with reconstituted mem markers. Returns None if no nodes found.
+    pub fn export_to_markdown(&self, file_key: &str) -> Option<String> {
+        let sections = self.file_sections(file_key)?;
+
+        let mut output = String::new();
+        for node in &sections {
+            if node.key.contains('#') {
+                let section_id = node.key.split('#').last().unwrap_or("");
+
+                let links: Vec<_> = self.relations.iter()
+                    .filter(|r| r.source_key == node.key && !r.deleted
+                            && r.rel_type != RelationType::Causal)
+                    .map(|r| r.target_key.clone())
+                    .collect();
+                let causes: Vec<_> = self.relations.iter()
+                    .filter(|r| r.target_key == node.key && !r.deleted
+                            && r.rel_type == RelationType::Causal)
+                    .map(|r| r.source_key.clone())
+                    .collect();
+
+                let mut marker_parts = vec![format!("id={}", section_id)];
+                if !links.is_empty() {
+                    marker_parts.push(format!("links={}", links.join(",")));
+                }
+                if !causes.is_empty() {
+                    marker_parts.push(format!("causes={}", causes.join(",")));
+                }
+
+                output.push_str(&format!("<!-- mem: {} -->\n", marker_parts.join(" ")));
+            }
+            output.push_str(&node.content);
+            if !node.content.ends_with('\n') {
+                output.push('\n');
+            }
+            output.push('\n');
+        }
+
+        Some(output.trim_end().to_string())
+    }
+
+    /// Find the journal node that best matches the given entry text.
+    /// Used by apply-agent to link agent results back to source entries.
+    pub fn find_journal_node(&self, entry_text: &str) -> Option<String> {
+        if entry_text.is_empty() {
+            return None;
+        }
+
+        let words: Vec<&str> = entry_text.split_whitespace()
+            .filter(|w| w.len() > 5)
+            .take(5)
+            .collect();
+
+        let mut best_key = None;
+        let mut best_score = 0;
+
+        for (key, node) in &self.nodes {
+            if !key.starts_with("journal.md#") {
+                continue;
+            }
+            let content_lower = node.content.to_lowercase();
+            let score: usize = words.iter()
+                .filter(|w| content_lower.contains(&w.to_lowercase()))
+                .count();
+            if score > best_score {
+                best_score = score;
+                best_key = Some(key.clone());
+            }
+        }
+
+        best_key
+    }
 }
 
 // Markdown parsing — same as old system but returns structured units