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> {