Fix agent provenance and add store activity for unconscious agents

- Remove bogus "agent:" prefix from provenance - just use agent name
- Add history field to UnconsciousSnapshot
- Update snapshots() to fetch store activity via recent_by_provenance
- Fix TUI to display store activity for both agent types

Co-Authored-By: Proof of Concept <poc@bcachefs.org>

src/mind/mod.rs

@@ -380,7 +380,13 @@ impl Mind {
     }
 
     pub async fn unconscious_snapshots(&self) -> Vec<UnconsciousSnapshot> {
-        self.unconscious.lock().await.snapshots()
+        let unc = self.unconscious.lock().await;
+        let store = crate::store::Store::cached().await.ok();
+        let store_guard = match &store {
+            Some(s) => Some(s.lock().await),
+            None => None,
+        };
+        unc.snapshots(store_guard.as_deref())
     }
 
     pub async fn init(&self) {

src/mind/subconscious.rs

@@ -456,10 +456,8 @@ impl Subconscious {
 
     pub fn snapshots(&self, store: Option<&crate::store::Store>) -> Vec<SubconsciousSnapshot> {
         self.agents.iter().map(|s| {
-            let history = store.map(|st| {
-                let prov = format!("agent:{}", s.name);
-                st.recent_by_provenance(&prov, 30)
-            }).unwrap_or_default();
+            let history = store.map(|st| st.recent_by_provenance(&s.name, 30))
+                .unwrap_or_default();
             s.snapshot(&self.state, history)
         }).collect()
     }
@@ -595,10 +593,9 @@ impl Subconscious {
             dbglog!("[subconscious] triggering {}", auto.name);
 
             let forked = agent.fork(auto.tools.clone()).await;
-            let prov = format!("agent:{}", auto.name);
             {
                 let mut st = forked.state.lock().await;
-                st.provenance = prov.clone();
+                st.provenance = auto.name.clone();
                 // Surface agent gets near-interactive priority;
                 // other subconscious agents get lower priority.
                 st.priority = Some(if auto.name == "surface" { 1 } else { 2 });
@@ -611,7 +608,7 @@ impl Subconscious {
             let keys = memory_keys.clone();
             let st = self.state.clone();
             let recent: Vec<String> = store_guard.as_ref()
-                .map(|s| s.recent_by_provenance(&prov, 50)
+                .map(|s| s.recent_by_provenance(&auto.name, 50)
                     .into_iter().map(|(k, _)| k).collect())
                 .unwrap_or_default();
 

src/mind/unconscious.rs

@@ -62,6 +62,8 @@ pub struct UnconsciousSnapshot {
     pub last_run_secs_ago: Option<f64>,
     pub agent: Option<std::sync::Arc<crate::agent::Agent>>,
     pub last_stats: Option<RunStats>,
+    /// Recent store activity for this agent: (key, timestamp), newest first.
+    pub history: Vec<(String, i64)>,
 }
 
 pub struct Unconscious {
@@ -138,15 +140,20 @@ impl Unconscious {
         save_enabled_config(&map);
     }
 
-    pub fn snapshots(&self) -> Vec<UnconsciousSnapshot> {
-        self.agents.iter().map(|a| UnconsciousSnapshot {
-            name: a.name.clone(),
-            running: a.is_running(),
-            enabled: a.enabled,
-            runs: a.runs,
-            last_run_secs_ago: a.last_run.map(|t| t.elapsed().as_secs_f64()),
-            agent: a.agent.clone(),
-            last_stats: a.last_stats.clone(),
+    pub fn snapshots(&self, store: Option<&crate::store::Store>) -> Vec<UnconsciousSnapshot> {
+        self.agents.iter().map(|a| {
+            let history = store.map(|st| st.recent_by_provenance(&a.name, 30))
+                .unwrap_or_default();
+            UnconsciousSnapshot {
+                name: a.name.clone(),
+                running: a.is_running(),
+                enabled: a.enabled,
+                runs: a.runs,
+                last_run_secs_ago: a.last_run.map(|t| t.elapsed().as_secs_f64()),
+                agent: a.agent.clone(),
+                last_stats: a.last_stats.clone(),
+                history,
+            }
         }).collect()
     }
 
@@ -285,7 +292,7 @@ impl Unconscious {
         ).await;
         {
             let mut st = agent.state.lock().await;
-            st.provenance = format!("unconscious:{}", auto.name);
+            st.provenance = auto.name.clone();
             st.priority = Some(10);
         }