kent/consciousness
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

organize: topic cluster diagnostic + agent with tool access

Browse source 
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).
This commit is contained in:
ProofOfConcept 2026-03-13 18:49:49 -04:00
parent 1da712874b
commit 76b8e69749
3 changed files with 316 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

74
poc-memory/src/agents/defs.rs
View file

@ -32,6 +32,7 @@ pub struct AgentDef {
pub prompt: String,
pub model: String,
pub schedule: String,
pub tools: Vec<String>,
}
/// The JSON header portion (first line of the file).
@ -44,6 +45,8 @@ struct AgentHeader {
model: String,
#[serde(default)]
schedule: String,
#[serde(default)]
tools: Vec<String>,
}
fn default_model() -> String { "sonnet".into() }
@ -60,6 +63,7 @@ fn parse_agent_file(content: &str) -> Option<AgentDef> {
prompt: prompt.to_string(),
model: header.model,
schedule: header.schedule,
tools: header.tools,
})
}
@ -160,6 +164,76 @@ fn resolve(
})
}
"organize" => {
// Run cluster diagnostic for the query term
// The query field of the agent def holds the search term
let term = if keys.is_empty() { "" } else { &keys[0] };
if term.is_empty() {
return Some(Resolved { text: "(no term provided)".into(), keys: vec![] });
}
let term_lower = term.to_lowercase();
let skip_prefixes = ["journal#", "daily-", "weekly-", "monthly-", "_",
"deep-index#", "facts-", "irc-history#"];
let mut cluster: Vec<(String, String)> = Vec::new();
for (key, node) in &store.nodes {
if node.deleted { continue; }
if !key.to_lowercase().contains(&term_lower) { continue; }
if skip_prefixes.iter().any(|p| key.starts_with(p)) { continue; }
cluster.push((key.clone(), node.content.clone()));
}
cluster.sort_by(|a, b| a.0.cmp(&b.0));
// Similarity pairs
let pairs = crate::similarity::pairwise_similar(&cluster, 0.4);
let mut text = format!("### Cluster: '{}' ({} nodes)\n\n", term, cluster.len());
// Similarity report
if !pairs.is_empty() {
text.push_str("#### Similarity scores\n\n");
for (a, b, sim) in &pairs {
text.push_str(&format!(" [{:.3}] {} ↔ {}\n", sim, a, b));
}
text.push('\n');
}
// Connectivity
let cluster_keys: std::collections::HashSet<&str> = cluster.iter()
.map(|(k,_)| k.as_str()).collect();
let mut best_hub: Option<(&str, usize)> = None;
for key in &cluster_keys {
let intra = graph.neighbor_keys(key).iter()
.filter(|n| cluster_keys.contains(*n))
.count();
if best_hub.is_none() || intra > best_hub.unwrap().1 {
best_hub = Some((key, intra));
}
}
if let Some((hub, deg)) = best_hub {
text.push_str(&format!("#### Hub: {} (intra-cluster degree {})\n\n", hub, deg));
let hub_nbrs = graph.neighbor_keys(hub);
for key in &cluster_keys {
if *key == hub { continue; }
if !hub_nbrs.contains(*key) {
text.push_str(&format!(" NOT linked to hub: {}\n", key));
}
}
text.push('\n');
}
// Full node contents
text.push_str("#### Node contents\n\n");
let mut result_keys = Vec::new();
for (key, content) in &cluster {
let words = content.split_whitespace().count();
text.push_str(&format!("##### {} ({} words)\n\n{}\n\n---\n\n", key, words, content));
result_keys.push(key.clone());
}
Some(Resolved { text, keys: result_keys })
}
"conversations" => {
let fragments = super::knowledge::select_conversation_fragments(count);
let text = fragments.iter()

138
poc-memory/src/main.rs
View file

@ -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();