Tier 1: Graph Memory (Grafeo)     — Relationship-aware indexed recall
Tier 2: Flat Files (memdir)       — Claude Code compatible .md files
Tier 3: CLAUDE.md Hierarchy       — 4-level instruction loading
       + Session Storage (JSONL)  — Append-only transcripts

use cersei::memory::manager::MemoryManager;

let mm = MemoryManager::new(project_root)
    .with_graph(Path::new("./memory.grafeo"))?;

// Build the complete memory context for the system prompt
let context = mm.build_context();

// Scan all memory files
for meta in mm.scan() {
    println!("{}: {} (type: {:?})", meta.filename, meta.description.unwrap_or_default(), meta.memory_type);
}

// Recall — graph indexed lookup in 98us, or text scan in 1.3ms
let results = mm.recall("testing preferences", 5);

// Filter by type
let user_memories = mm.by_type(MemoryType::User);

// Filter by topic
let rust_memories = mm.by_topic("rust");

// Store a memory
let id = mm.store_memory(
    "User prefers functional patterns over OOP",
    MemoryType::User,
    0.9,  // confidence 0.0 to 1.0
);

// Tag it
if let Some(ref id) = id {
    mm.tag_memory(id, "coding-style");
    mm.tag_memory(id, "preferences");
}

// Link two memories
mm.link_memories(&id_a, &id_b, "contradicts");
mm.link_memories(&id_c, &id_d, "extends");

// Check stats
let stats = mm.graph_stats();
println!("{} memories, {} topics, {} relationships", stats.memory_count, stats.topic_count, stats.relationship_count);

// Write
let user_id = mm.write_user_message("session-1", Message::user("Hello"))?;
let asst_id = mm.write_assistant_message("session-1", Message::assistant("Hi!"), Some(&user_id))?;

// Load
let messages = mm.load_session_messages("session-1")?;
assert_eq!(messages.len(), 2);

Node Types:
  (:Memory) { id, content, mem_type, confidence, created_at, updated_at }
  (:Topic)  { name }
  (:Session) { session_id, started_at, model, turns }

Edge Types:
  (:Memory) -[:RELATES_TO { relationship, weight }]-> (:Memory)
  (:Topic)  -[:TAGGED]->                              (:Memory)
  (:Session) -[:PRODUCED]->                           (:Memory)

---
name: Memory Title
description: One-line description for recall
type: user
---

Actual memory content here.

let dreamer = AutoDream::new(memory_dir, conversations_dir);

if dreamer.should_consolidate() {
    dreamer.acquire_lock()?;
    // Run consolidation agent...
    dreamer.update_state()?;
    dreamer.release_lock()?;
}

// Check if extraction should run
if session_memory::should_extract(&messages, &state) {
    // Parse extraction output from the model
    let memories = session_memory::parse_extraction_output(&model_output);

    // Persist to memory directory
    session_memory::persist_memories(&memories, &memory_path)?;
}