agent visits: track when agents successfully process nodes

New append-only visits.capnp log records which agent processed which
node and when. Only recorded on successful completion — transient
errors don't mark nodes as "seen."

Schema: AgentVisit{nodeUuid, nodeKey, agent, timestamp, outcome}
Storage: append_visits(), replay_visits(), in-memory VisitIndex
Recording: daemon records visits after successful LLM call
API: agent_prompt() returns AgentBatch{prompt, node_keys} so callers
know which nodes to mark as visited.

Groundwork for using visit recency in agent node selection — agents
will deprioritize recently-visited nodes.

poc-memory/src/store/persist.rs

@@ -29,7 +29,14 @@ impl Store {
     pub fn load() -> Result<Store, String> {
         // 1. Try rkyv mmap snapshot (~4ms with deserialize, <1ms zero-copy)
         match Self::load_snapshot_mmap() {
-            Ok(Some(store)) => return Ok(store),
+            Ok(Some(mut store)) => {
+                // rkyv snapshot doesn't include visits — replay from log
+                let visits_p = visits_path();
+                if visits_p.exists() {
+                    store.replay_visits(&visits_p).ok();
+                }
+                return Ok(store);
+            },
             Ok(None) => {},
             Err(e) => eprintln!("rkyv snapshot: {}", e),
         }
@@ -76,6 +83,10 @@ impl Store {
         if rels_p.exists() {
             store.replay_relations(&rels_p)?;
         }
+        let visits_p = visits_path();
+        if visits_p.exists() {
+            store.replay_visits(&visits_p)?;
+        }
 
         // Record log sizes after replay — this is the state we reflect
         store.loaded_nodes_size = fs::metadata(&nodes_p).map(|m| m.len()).unwrap_or(0);
@@ -318,6 +329,100 @@ impl Store {
         Ok(())
     }
 
+    /// Append agent visit records to the visits log.
+    pub fn append_visits(&mut self, visits: &[AgentVisit]) -> Result<(), String> {
+        if visits.is_empty() { return Ok(()); }
+
+        let mut msg = message::Builder::new_default();
+        {
+            let log = msg.init_root::<memory_capnp::agent_visit_log::Builder>();
+            let mut list = log.init_visits(visits.len() as u32);
+            for (i, visit) in visits.iter().enumerate() {
+                visit.to_capnp(list.reborrow().get(i as u32));
+            }
+        }
+        let mut buf = Vec::new();
+        serialize::write_message(&mut buf, &msg)
+            .map_err(|e| format!("serialize visits: {}", e))?;
+
+        let path = visits_path();
+        let file = fs::OpenOptions::new()
+            .create(true).append(true).open(&path)
+            .map_err(|e| format!("open {}: {}", path.display(), e))?;
+        use std::io::Write;
+        (&file).write_all(&buf)
+            .map_err(|e| format!("write visits: {}", e))?;
+
+        // Update in-memory index
+        for v in visits {
+            self.visits
+                .entry(v.node_key.clone())
+                .or_default()
+                .insert(v.agent.clone(), v.timestamp);
+        }
+
+        Ok(())
+    }
+
+    /// Replay visits log to rebuild in-memory index.
+    fn replay_visits(&mut self, path: &Path) -> Result<(), String> {
+        let file = fs::File::open(path)
+            .map_err(|e| format!("open {}: {}", path.display(), e))?;
+        let mut reader = BufReader::new(file);
+
+        while reader.stream_position().map_err(|e| e.to_string())?
+              < fs::metadata(path).map_err(|e| e.to_string())?.len()
+        {
+            let msg = match serialize::read_message(&mut reader, Default::default()) {
+                Ok(m) => m,
+                Err(_) => break,
+            };
+            let log = msg.get_root::<memory_capnp::agent_visit_log::Reader>()
+                .map_err(|e| format!("read visit log: {}", e))?;
+
+            for visit in log.get_visits().map_err(|e| e.to_string())? {
+                let key = visit.get_node_key().ok()
+                    .and_then(|t| t.to_str().ok())
+                    .unwrap_or("")
+                    .to_string();
+                let agent = visit.get_agent().ok()
+                    .and_then(|t| t.to_str().ok())
+                    .unwrap_or("")
+                    .to_string();
+                let ts = visit.get_timestamp();
+
+                if !key.is_empty() && !agent.is_empty() {
+                    let entry = self.visits.entry(key).or_default();
+                    // Keep latest timestamp per agent
+                    let existing = entry.entry(agent).or_insert(0);
+                    if ts > *existing {
+                        *existing = ts;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Record visits for a batch of node keys from a successful agent run.
+    pub fn record_agent_visits(&mut self, node_keys: &[String], agent: &str) -> Result<(), String> {
+        let visits: Vec<AgentVisit> = node_keys.iter()
+            .filter_map(|key| {
+                let node = self.nodes.get(key)?;
+                Some(new_visit(node.uuid, key, agent, "processed"))
+            })
+            .collect();
+        self.append_visits(&visits)
+    }
+
+    /// Get the last time an agent visited a node. Returns 0 if never visited.
+    pub fn last_visited(&self, node_key: &str, agent: &str) -> i64 {
+        self.visits.get(node_key)
+            .and_then(|agents| agents.get(agent))
+            .copied()
+            .unwrap_or(0)
+    }
+
     /// Save the derived cache with log size header for staleness detection.
     /// Uses atomic write (tmp + rename) to prevent partial reads.
     pub fn save(&self) -> Result<(), String> {

poc-memory/src/store/types.rs

@@ -394,6 +394,9 @@ pub struct GapRecord {
     pub timestamp: String,
 }
 
+/// Per-node agent visit index: node_key → (agent_type → last_visit_timestamp)
+pub type VisitIndex = HashMap<String, HashMap<String, i64>>;
+
 // The full in-memory store
 #[derive(Default, Serialize, Deserialize)]
 pub struct Store {
@@ -404,6 +407,9 @@ pub struct Store {
     pub retrieval_log: Vec<RetrievalEvent>,
     pub gaps: Vec<GapRecord>,
     pub params: Params,
+    /// Agent visit tracking: node_key → (agent_type → last_visit_epoch)
+    #[serde(default)]
+    pub visits: VisitIndex,
     /// Log sizes at load time — used by save() to write correct staleness header.
     /// If another writer appended since we loaded, our cache will be marked stale
     /// (recorded size < actual size), forcing the next reader to replay the log.
@@ -490,6 +496,38 @@ pub fn new_node(key: &str, content: &str) -> Node {
     }
 }
 
+/// Agent visit record — tracks when an agent successfully processed a node
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct AgentVisit {
+    pub node_uuid: [u8; 16],
+    pub node_key: String,
+    pub agent: String,
+    pub timestamp: i64,
+    pub outcome: String,
+}
+
+capnp_message!(AgentVisit,
+    reader: memory_capnp::agent_visit::Reader<'_>,
+    builder: memory_capnp::agent_visit::Builder<'_>,
+    text: [node_key, agent, outcome],
+    uuid: [node_uuid],
+    prim: [timestamp],
+    enm:  [],
+    skip: [],
+);
+
+pub fn new_visit(node_uuid: [u8; 16], node_key: &str, agent: &str, outcome: &str) -> AgentVisit {
+    AgentVisit {
+        node_uuid,
+        node_key: node_key.to_string(),
+        agent: agent.to_string(),
+        timestamp: now_epoch(),
+        outcome: outcome.to_string(),
+    }
+}
+
+pub(crate) fn visits_path() -> PathBuf { memory_dir().join("visits.capnp") }
+
 /// Create a new relation
 pub fn new_relation(
     source_uuid: [u8; 16],