CLI: more RPC conversions, delete obsolete commands

- cmd_health: use graph_health RPC
- cmd_topology: new command using graph_topology RPC
- cmd_status: use graph_topology RPC (type counts folded into topology)
- cmd_run_agent: query resolution via memory_query RPC
- Delete cmd_bulk_rename (one-time migration, obsolete)
- Delete cmd_replay_queue, cmd_digest_links (unconscious agents handle)
- format_topology_header: add type counts, takes &Store now

Co-Authored-By: Kent Overstreet <kent.overstreet@linux.dev>

src/cli/agent.rs

@@ -1,7 +1,6 @@
 // cli/agent.rs — agent subcommand handlers
 
 use crate::store;
-use crate::subconscious::digest;
 
 pub fn cmd_run_agent(agent: &str, count: usize, target: &[String], query: Option<&str>, dry_run: bool, _local: bool, state_dir: Option<&str>) -> Result<(), String> {
     // Mark as agent so tool calls (e.g. poc-memory render) don't
@@ -19,19 +18,22 @@ pub fn cmd_run_agent(agent: &str, count: usize, target: &[String], query: Option
         unsafe { std::env::set_var("POC_MEMORY_DRY_RUN", "1"); }
     }
 
-    let mut store = store::Store::load()?;
-
     // Resolve targets: explicit --target, --query, or agent's default query
     let resolved_targets: Vec<String> = if !target.is_empty() {
         target.to_vec()
     } else if let Some(q) = query {
-        let graph = store.build_graph();
-        let stages = crate::query_parser::parse_stages(q)?;
-        let results = crate::search::run_query(&stages, vec![], &graph, &store, false, count);
-        if results.is_empty() {
+        // Use RPC to resolve query
+        let result = crate::mcp_server::memory_rpc(
+            "memory_query",
+            serde_json::json!({"query": format!("{} | limit:{}", q, count)}),
+        ).map_err(|e| e.to_string())?;
+        let keys: Vec<String> = result.lines()
+            .filter(|l| !l.is_empty() && *l != "no results")
+            .map(|s| s.to_string())
+            .collect();
+        if keys.is_empty() {
             return Err(format!("query returned no results: {}", q));
         }
-        let keys: Vec<String> = results.into_iter().map(|(k, _)| k).collect();
         println!("[{}] query matched {} nodes", agent, keys.len());
         keys
     } else {
@@ -41,7 +43,7 @@ pub fn cmd_run_agent(agent: &str, count: usize, target: &[String], query: Option
     if !resolved_targets.is_empty() {
         for (i, key) in resolved_targets.iter().enumerate() {
             println!("[{}] [{}/{}] {}", agent, i + 1, resolved_targets.len(), key);
-            if i > 0 { store = store::Store::load()?; }
+            let mut store = store::Store::load()?;
             if let Err(e) = crate::agent::oneshot::run_one_agent(
                 &mut store, agent, count, Some(&[key.clone()]),
             ) {
@@ -50,6 +52,7 @@ pub fn cmd_run_agent(agent: &str, count: usize, target: &[String], query: Option
         }
     } else {
         // Local execution (--local, --debug, dry-run, or daemon unavailable)
+        let mut store = store::Store::load()?;
         crate::agent::oneshot::run_one_agent(
             &mut store, agent, count, None,
         )?;
@@ -57,37 +60,3 @@ pub fn cmd_run_agent(agent: &str, count: usize, target: &[String], query: Option
     Ok(())
 }
 
-pub fn cmd_replay_queue(count: usize) -> Result<(), String> {
-    let store = store::Store::load()?;
-    let queue = crate::neuro::replay_queue(&store, count);
-    println!("Replay queue ({} items):", queue.len());
-    for (i, item) in queue.iter().enumerate() {
-        println!("  {:2}. [{:.3}] {:>10}  {} (interval={}d, emotion={:.1}, spectral={:.1})",
-            i + 1, item.priority, item.classification, item.key,
-            item.interval_days, item.emotion, item.outlier_score);
-    }
-    Ok(())
-}
-
-pub fn cmd_digest_links(do_apply: bool) -> Result<(), String> {
-    let store = store::Store::load()?;
-    let links = digest::parse_all_digest_links(&store);
-    drop(store);
-    println!("Found {} unique links from digest nodes", links.len());
-
-    if !do_apply {
-        for (i, link) in links.iter().enumerate() {
-            println!("  {:3}. {} → {}", i + 1, link.source, link.target);
-            if !link.reason.is_empty() {
-                println!("       ({})", &link.reason[..link.reason.floor_char_boundary(link.reason.len().min(80))]);
-            }
-        }
-        println!("\nTo apply: poc-memory digest-links --apply");
-        return Ok(());
-    }
-
-    let mut store = store::Store::load()?;
-    let (applied, skipped, fallbacks) = digest::apply_digest_links(&mut store, &links);
-    println!("\nApplied: {} ({} file-level fallbacks)  Skipped: {}", applied, fallbacks, skipped);
-    Ok(())
-}