organize: topic cluster diagnostic + agent with tool access

Add `poc-memory graph organize TERM` diagnostic that finds nodes
matching a search term, computes pairwise cosine similarity, reports
connectivity gaps, and optionally creates anchor nodes.

Add organize.agent definition that uses Bash(poc-memory:*) tool access
to explore clusters autonomously — query selects highest-degree
unvisited nodes, agent drives its own iteration via poc-memory CLI.

Add {{organize}} placeholder in defs.rs for inline cluster resolution.

Add `tools` field to AgentDef/AgentHeader so agents can declare
allowed tool patterns (passed as --allowedTools to claude CLI).

poc-memory/src/main.rs

@@ -392,6 +392,20 @@ enum GraphCmd {
         #[arg(default_value_t = 20)]
         n: usize,
     },
+    /// Diagnose duplicate/overlapping nodes for a topic cluster
+    Organize {
+        /// Search term (matches node keys; also content unless --key-only)
+        term: String,
+        /// Similarity threshold for pair reporting (default: 0.4)
+        #[arg(long, default_value_t = 0.4)]
+        threshold: f32,
+        /// Only match node keys, not content
+        #[arg(long)]
+        key_only: bool,
+        /// Create anchor node for the search term and link to cluster
+        #[arg(long)]
+        anchor: bool,
+    },
 }
 
 #[derive(Subcommand)]
@@ -640,6 +654,8 @@ fn main() {
                 => cmd_spectral_neighbors(&key, n),
             GraphCmd::SpectralPositions { n } => cmd_spectral_positions(n),
             GraphCmd::SpectralSuggest { n } => cmd_spectral_suggest(n),
+            GraphCmd::Organize { term, threshold, key_only, anchor }
+                => cmd_organize(&term, threshold, key_only, anchor),
         },
 
         // Agent
@@ -2485,6 +2501,128 @@ fn extract_title(content: &str) -> String {
     String::from("(untitled)")
 }
 
+fn cmd_organize(term: &str, threshold: f32, key_only: bool, create_anchor: bool) -> Result<(), String> {
+    let mut store = store::Store::load()?;
+
+    // Step 1: find all non-deleted nodes matching the term
+    let term_lower = term.to_lowercase();
+    let mut topic_nodes: Vec<(String, String)> = Vec::new(); // (key, content)
+
+    // Prefixes that indicate ephemeral/generated nodes to skip
+    let skip_prefixes = ["journal#", "daily-", "weekly-", "monthly-", "_",
+                         "deep-index#", "facts-", "irc-history#"];
+
+    for (key, node) in &store.nodes {
+        if node.deleted { continue; }
+        let key_matches = key.to_lowercase().contains(&term_lower);
+        let content_matches = !key_only && node.content.to_lowercase().contains(&term_lower);
+        if !key_matches && !content_matches { continue; }
+        if skip_prefixes.iter().any(|p| key.starts_with(p)) { continue; }
+        topic_nodes.push((key.clone(), node.content.clone()));
+    }
+
+    if topic_nodes.is_empty() {
+        println!("No topic nodes found matching '{}'", term);
+        return Ok(());
+    }
+
+    topic_nodes.sort_by(|a, b| a.0.cmp(&b.0));
+
+    println!("=== Organize: '{}' ===", term);
+    println!("Found {} topic nodes:\n", topic_nodes.len());
+    for (key, content) in &topic_nodes {
+        let lines = content.lines().count();
+        let words = content.split_whitespace().count();
+        println!("  {:60} {:>4} lines  {:>5} words", key, lines, words);
+    }
+
+    // Step 2: pairwise similarity
+    let pairs = similarity::pairwise_similar(&topic_nodes, threshold);
+
+    if pairs.is_empty() {
+        println!("\nNo similar pairs above threshold {:.2}", threshold);
+    } else {
+        println!("\n=== Similar pairs (cosine > {:.2}) ===\n", threshold);
+        for (a, b, sim) in &pairs {
+            let a_words = topic_nodes.iter().find(|(k,_)| k == a)
+                .map(|(_,c)| c.split_whitespace().count()).unwrap_or(0);
+            let b_words = topic_nodes.iter().find(|(k,_)| k == b)
+                .map(|(_,c)| c.split_whitespace().count()).unwrap_or(0);
+
+            println!("  [{:.3}] {} ({} words) ↔ {} ({} words)", sim, a, a_words, b, b_words);
+        }
+    }
+
+    // Step 3: check connectivity within cluster
+    let g = store.build_graph();
+    println!("=== Connectivity ===\n");
+
+    // Pick hub by intra-cluster connectivity, not overall degree
+    let cluster_keys: std::collections::HashSet<&str> = topic_nodes.iter()
+        .filter(|(k,_)| store.nodes.contains_key(k.as_str()))
+        .map(|(k,_)| k.as_str())
+        .collect();
+
+    let mut best_hub: Option<(&str, usize)> = None;
+    for key in &cluster_keys {
+        let intra_degree = g.neighbor_keys(key).iter()
+            .filter(|n| cluster_keys.contains(*n))
+            .count();
+        if best_hub.is_none() || intra_degree > best_hub.unwrap().1 {
+            best_hub = Some((key, intra_degree));
+        }
+    }
+
+    if let Some((hub, deg)) = best_hub {
+        println!("  Hub: {} (degree {})", hub, deg);
+        let hub_nbrs = g.neighbor_keys(hub);
+
+        let mut unlinked = Vec::new();
+        for (key, _) in &topic_nodes {
+            if key == hub { continue; }
+            if store.nodes.get(key.as_str()).is_none() { continue; }
+            if !hub_nbrs.contains(key.as_str()) {
+                unlinked.push(key.clone());
+            }
+        }
+
+        if unlinked.is_empty() {
+            println!("  All cluster nodes connected to hub ✓");
+        } else {
+            println!("  NOT linked to hub:");
+            for key in &unlinked {
+                println!("    {} → needs link to {}", key, hub);
+            }
+        }
+    }
+
+    // Step 4: anchor node
+    if create_anchor {
+        println!("\n=== Anchor node ===\n");
+        if store.nodes.contains_key(term) && !store.nodes[term].deleted {
+            println!("  Anchor '{}' already exists ✓", term);
+        } else {
+            let desc = format!("Anchor node for '{}' search term", term);
+            store.upsert(term, &desc)?;
+            let anchor_uuid = store.nodes.get(term).unwrap().uuid;
+            for (key, _) in &topic_nodes {
+                if store.nodes.get(key.as_str()).is_none() { continue; }
+                let target_uuid = store.nodes[key.as_str()].uuid;
+                let rel = store::new_relation(
+                    anchor_uuid, target_uuid,
+                    store::RelationType::Link, 0.8,
+                    term, key,
+                );
+                store.add_relation(rel)?;
+            }
+            println!("  Created anchor '{}' with {} links", term, topic_nodes.len());
+        }
+    }
+
+    store.save()?;
+    Ok(())
+}
+
 fn cmd_interference(threshold: f32) -> Result<(), String> {
     let store = store::Store::load()?;
     let g = store.build_graph();