spqrz/consciousness
1
0
Fork 0
forked from kent/consciousness
Code Pull requests Activity

Add enabled toggle to AutoAgent, simplify unconscious scheduling

Browse source 
- AutoAgent.enabled: universal toggle for any auto agent
- Subconscious: should_trigger checks auto.enabled
- Unconscious: simplified from consolidation-plan-driven budgets to
  simple loop with cooldown. Static agent list, max 2 concurrent.
- TUI: unconscious agents shown in F3 subconscious screen under
  separator, with enabled/running/runs display

Co-Authored-By: Proof of Concept <poc@bcachefs.org>
This commit is contained in:
ProofOfConcept 2026-04-09 00:41:18 -04:00
parent ddfdbe6cb1
commit 1df49482fd
5 changed files with 99 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/mind/subconscious.rs
View file

@ -291,6 +291,7 @@ const AGENTS: &[(&str, u64)] = &[
pub struct SubconsciousSnapshot {
pub name: String,
pub running: bool,
pub enabled: bool,
pub current_phase: String,
pub turn: usize,
pub last_run_secs_ago: Option<f64>,
@ -352,7 +353,7 @@ impl SubconsciousAgent {
}
fn should_trigger(&self, conversation_bytes: u64, interval: u64) -> bool {
if self.is_running() { return false; }
if !self.auto.enabled || self.is_running() { return false; }
if interval == 0 { return true; }
conversation_bytes.saturating_sub(self.last_trigger_bytes) >= interval
}
@ -361,6 +362,7 @@ impl SubconsciousAgent {
SubconsciousSnapshot {
name: self.name.clone(),
running: self.is_running(),
enabled: self.auto.enabled,
current_phase: self.auto.current_phase.clone(),
turn: self.auto.turn,
last_run_secs_ago: self.last_run.map(|t| t.elapsed().as_secs_f64()),

143
src/mind/unconscious.rs
View file

@ -1,13 +1,8 @@
// unconscious.rs — Graph maintenance agents
//
// Standalone agents that operate on the memory graph without needing
// conversation context. Unlike subconscious agents (which fork the
// conscious agent to share KV cache), unconscious agents create fresh
// Agent instances and select their own target nodes via queries
// defined in their .agent files.
//
// Scheduling is driven by the consolidation plan (neuro/scoring.rs),
// which analyzes graph health metrics and allocates agent runs.
// conversation context. Each agent runs in a loop: finish one run,
// wait a cooldown, start the next. Agents can be toggled on/off.
use std::time::{Duration, Instant};
@ -15,31 +10,47 @@ use crate::agent::oneshot::{AutoAgent, AutoStep};
use crate::agent::tools;
use crate::subconscious::defs;
/// A single unconscious agent type and its runtime state.
/// Agent types to run. Each must have a matching .agent file.
const AGENTS: &[&str] = &[
"organize",
"linker",
"distill",
"split",
"separator",
];
/// Cooldown between consecutive runs of the same agent.
const COOLDOWN: Duration = Duration::from_secs(120);
struct UnconsciousAgent {
name: String,
/// How many runs are budgeted (from consolidation plan).
budget: usize,
/// How many runs completed this session.
completed: usize,
/// Currently running task.
enabled: bool,
handle: Option<tokio::task::JoinHandle<(AutoAgent, Result<String, String>)>>,
last_run: Option<Instant>,
runs: usize,
}
impl UnconsciousAgent {
fn new(name: &str) -> Self {
Self {
name: name.to_string(),
enabled: true,
handle: None,
last_run: None,
runs: 0,
}
}
fn is_running(&self) -> bool {
self.handle.as_ref().is_some_and(|h| !h.is_finished())
}
fn should_run(&self) -> bool {
if self.is_running() { return false; }
if self.completed >= self.budget { return false; }
// Min interval between runs of the same agent type
if let Some(last) = self.last_run {
if last.elapsed() < Duration::from_secs(60) { return false; }
if !self.enabled || self.is_running() { return false; }
match self.last_run {
Some(t) => t.elapsed() >= COOLDOWN,
None => true,
}
true
}
}
@ -48,123 +59,78 @@ impl UnconsciousAgent {
pub struct UnconsciousSnapshot {
pub name: String,
pub running: bool,
pub completed: usize,
pub budget: usize,
pub enabled: bool,
pub runs: usize,
pub last_run_secs_ago: Option<f64>,
}
/// Orchestrates standalone graph maintenance agents.
pub struct Unconscious {
agents: Vec<UnconsciousAgent>,
/// Max concurrent agent runs.
max_concurrent: usize,
/// When we last refreshed the consolidation plan.
last_plan_refresh: Option<Instant>,
}
impl Unconscious {
pub fn new() -> Self {
Self {
agents: Vec::new(),
max_concurrent: 2,
last_plan_refresh: None,
}
let agents = AGENTS.iter()
.filter(|name| defs::get_def(name).is_some())
.map(|name| UnconsciousAgent::new(name))
.collect();
Self { agents, max_concurrent: 2 }
}
/// Refresh the consolidation plan and update agent budgets.
fn refresh_plan(&mut self) {
let store = match crate::store::Store::load() {
Ok(s) => s,
Err(_) => return,
};
let plan = crate::neuro::consolidation_plan_quick(&store);
// Update existing agents or create new ones
for (agent_name, &count) in &plan.counts {
if count == 0 { continue; }
// Only include agents that have .agent definitions
if defs::get_def(agent_name).is_none() { continue; }
if let Some(existing) = self.agents.iter_mut().find(|a| a.name == *agent_name) {
existing.budget = count;
} else {
self.agents.push(UnconsciousAgent {
name: agent_name.clone(),
budget: count,
completed: 0,
handle: None,
last_run: None,
});
}
}
self.last_plan_refresh = Some(Instant::now());
dbglog!("[unconscious] plan refreshed: {} agent types, {} total runs",
self.agents.len(),
self.agents.iter().map(|a| a.budget).sum::<usize>());
/// Toggle an agent on/off by name. Returns new enabled state.
pub fn toggle(&mut self, name: &str) -> Option<bool> {
let agent = self.agents.iter_mut().find(|a| a.name == name)?;
agent.enabled = !agent.enabled;
Some(agent.enabled)
}
pub fn snapshots(&self) -> Vec<UnconsciousSnapshot> {
self.agents.iter().map(|a| UnconsciousSnapshot {
name: a.name.clone(),
running: a.is_running(),
completed: a.completed,
budget: a.budget,
enabled: a.enabled,
runs: a.runs,
last_run_secs_ago: a.last_run.map(|t| t.elapsed().as_secs_f64()),
}).collect()
}
/// Trigger agents that are due to run.
/// Reap finished agents and spawn new ones.
pub fn trigger(&mut self) {
// Reap finished agents
for agent in &mut self.agents {
if agent.handle.as_ref().is_some_and(|h| h.is_finished()) {
agent.last_run = Some(Instant::now());
agent.completed += 1;
dbglog!("[unconscious] {} completed ({}/{})",
agent.name, agent.completed, agent.budget);
agent.runs += 1;
dbglog!("[unconscious] {} completed (run {})",
agent.name, agent.runs);
agent.handle = None;
}
}
// Refresh plan every 30 minutes (or on first call)
let should_refresh = self.last_plan_refresh
.map(|t| t.elapsed() > Duration::from_secs(1800))
.unwrap_or(true);
if should_refresh {
self.refresh_plan();
}
// Count currently running
let running = self.agents.iter().filter(|a| a.is_running()).count();
if running >= self.max_concurrent { return; }
let slots = self.max_concurrent - running;
// Find agents that should run, sorted by most work remaining
let mut candidates: Vec<usize> = self.agents.iter().enumerate()
let ready: Vec<usize> = self.agents.iter().enumerate()
.filter(|(_, a)| a.should_run())
.map(|(i, _)| i)
.take(slots)
.collect();
candidates.sort_by_key(|&i| std::cmp::Reverse(
self.agents[i].budget - self.agents[i].completed
));
for idx in candidates.into_iter().take(slots) {
for idx in ready {
self.spawn_agent(idx);
}
}
fn spawn_agent(&mut self, idx: usize) {
let name = self.agents[idx].name.clone();
dbglog!("[unconscious] spawning {} ({}/{})",
name, self.agents[idx].completed + 1, self.agents[idx].budget);
dbglog!("[unconscious] spawning {}", name);
let def = match defs::get_def(&name) {
Some(d) => d,
None => return,
};
// Build tools
let all_tools = tools::memory_and_journal_tools();
let effective_tools: Vec<tools::Tool> = if def.tools.is_empty() {
all_tools
@ -174,7 +140,6 @@ impl Unconscious {
.collect()
};
// Run query, resolve placeholders, record visits
let mut store = match crate::store::Store::load() {
Ok(s) => s,
Err(e) => {
@ -204,9 +169,7 @@ impl Unconscious {
}).collect();
let mut auto = AutoAgent::new(
name.clone(),
effective_tools,
steps,
name, effective_tools, steps,
def.temperature.unwrap_or(0.6),
def.priority,
);