50b7b3a33a
Wire up divergence scoring to identify responses that depend heavily on memories the model hasn't internalized. These are candidates for fine-tuning. - Score finetune candidates automatically after each turn - Track trained responses by timestamp to prevent overtraining - F6 screen shows candidates with divergence scores - j/k nav, a=approve, r=reject, g=toggle alternate gen, s=send - Additive sync preserves approval status across ticks - Keeps 10 most recent rejected, removes sent The 's' key currently just marks as trained locally — actual /finetune endpoint call to follow. Co-Authored-By: Proof of Concept <poc@bcachefs.org>
792 lines
30 KiB
Rust
792 lines
30 KiB
Rust
// mind/ — Cognitive layer
|
||
//
|
||
// Mind state machine, DMN, identity, observation socket.
|
||
// Everything about how the mind operates, separate from the
|
||
// user interface (TUI, CLI) and the agent execution (tools, API).
|
||
|
||
pub mod subconscious;
|
||
pub mod unconscious;
|
||
pub mod identity;
|
||
pub mod log;
|
||
|
||
// consciousness.rs — Mind state machine and event loop
|
||
//
|
||
// The core runtime for the consciousness binary. Mind manages turns,
|
||
// DMN state, compaction, scoring, and slash commands. The event loop
|
||
// bridges Mind (cognitive state) with App (TUI rendering).
|
||
//
|
||
// The event loop uses biased select! so priorities are deterministic:
|
||
// keyboard events > turn results > render ticks > DMN timer > UI messages.
|
||
|
||
use anyhow::Result;
|
||
use std::sync::Arc;
|
||
use std::time::Instant;
|
||
use tokio::sync::mpsc;
|
||
use crate::agent::{Agent, TurnResult};
|
||
use crate::agent::api::ApiClient;
|
||
use crate::config::{AppConfig, SessionConfig};
|
||
use crate::subconscious::learn;
|
||
use crate::hippocampus::access_local;
|
||
|
||
pub use subconscious::{SubconsciousSnapshot, Subconscious};
|
||
pub use unconscious::{UnconsciousSnapshot, Unconscious};
|
||
|
||
use crate::agent::context::{AstNode, NodeBody, Section, Ast, ContextState};
|
||
|
||
fn match_scores(
|
||
nodes: &[AstNode],
|
||
scores: &std::collections::BTreeMap<String, f64>,
|
||
) -> Vec<(usize, f64)> {
|
||
nodes.iter().enumerate()
|
||
.filter_map(|(i, node)| {
|
||
if let AstNode::Leaf(leaf) = node {
|
||
if let NodeBody::Memory { key, .. } = leaf.body() {
|
||
return scores.get(key.as_str()).map(|&s| (i, s));
|
||
}
|
||
}
|
||
None
|
||
}).collect()
|
||
}
|
||
|
||
fn find_memory_by_key(ctx: &ContextState, key: &str) -> Option<(Section, usize)> {
|
||
[(Section::Identity, ctx.identity()), (Section::Conversation, ctx.conversation())]
|
||
.into_iter()
|
||
.find_map(|(section, nodes)| {
|
||
nodes.iter().enumerate().find_map(|(i, node)| {
|
||
if let AstNode::Leaf(leaf) = node {
|
||
if let NodeBody::Memory { key: k, .. } = leaf.body() {
|
||
if k == key { return Some((section, i)); }
|
||
}
|
||
}
|
||
None
|
||
})
|
||
})
|
||
}
|
||
|
||
fn load_memory_scores(ctx: &mut ContextState, path: &std::path::Path) {
|
||
let data = match std::fs::read_to_string(path) {
|
||
Ok(d) => d,
|
||
Err(_) => return,
|
||
};
|
||
let scores: std::collections::BTreeMap<String, f64> = match serde_json::from_str(&data) {
|
||
Ok(s) => s,
|
||
Err(_) => return,
|
||
};
|
||
let identity_scores = match_scores(ctx.identity(), &scores);
|
||
let conv_scores = match_scores(ctx.conversation(), &scores);
|
||
let applied = identity_scores.len() + conv_scores.len();
|
||
for (i, s) in identity_scores {
|
||
ctx.set_score(Section::Identity, i, Some(s));
|
||
}
|
||
for (i, s) in conv_scores {
|
||
ctx.set_score(Section::Conversation, i, Some(s));
|
||
}
|
||
if applied > 0 {
|
||
dbglog!("[scoring] loaded {} scores from {}", applied, path.display());
|
||
}
|
||
}
|
||
|
||
/// Collect scored memory keys from identity and conversation entries.
|
||
fn collect_memory_scores(ctx: &ContextState) -> std::collections::BTreeMap<String, f64> {
|
||
ctx.identity().iter()
|
||
.chain(ctx.conversation().iter())
|
||
.filter_map(|node| {
|
||
if let AstNode::Leaf(leaf) = node {
|
||
if let NodeBody::Memory { key, score: Some(s), .. } = leaf.body() {
|
||
return Some((key.clone(), *s));
|
||
}
|
||
}
|
||
None
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// Save memory scores to disk.
|
||
fn save_memory_scores(scores: &std::collections::BTreeMap<String, f64>, path: &std::path::Path) {
|
||
if let Ok(json) = serde_json::to_string_pretty(scores) {
|
||
let _ = std::fs::write(path, json);
|
||
dbglog!("[scoring] saved {} scores to {}", scores.len(), path.display());
|
||
}
|
||
}
|
||
|
||
/// Which pane streaming text should go to.
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum StreamTarget {
|
||
/// User-initiated turn — text goes to conversation pane.
|
||
Conversation,
|
||
/// DMN-initiated turn — text goes to autonomous pane.
|
||
Autonomous,
|
||
}
|
||
|
||
/// Compaction threshold — context is rebuilt when prompt tokens exceed this.
|
||
fn compaction_threshold(app: &AppConfig) -> u32 {
|
||
(crate::agent::context::context_window() as u32) * app.compaction.hard_threshold_pct / 100
|
||
}
|
||
|
||
/// Shared state between Mind and UI.
|
||
pub struct MindState {
|
||
/// Pending user input — UI pushes, Mind consumes after turn completes.
|
||
pub input: Vec<String>,
|
||
/// True while a turn is in progress.
|
||
pub turn_active: bool,
|
||
/// DMN state
|
||
pub dmn: subconscious::State,
|
||
pub dmn_turns: u32,
|
||
pub max_dmn_turns: u32,
|
||
/// Whether memory scoring is running.
|
||
pub scoring_in_flight: bool,
|
||
/// Whether compaction is running.
|
||
pub compaction_in_flight: bool,
|
||
/// Per-turn tracking
|
||
pub last_user_input: Instant,
|
||
pub consecutive_errors: u32,
|
||
pub last_turn_had_tools: bool,
|
||
/// Handle to the currently running turn task.
|
||
pub turn_handle: Option<tokio::task::JoinHandle<()>>,
|
||
/// Unconscious agent idle state — true when 60s timer has expired.
|
||
pub unc_idle: bool,
|
||
/// When the unconscious idle timer will fire (for UI display).
|
||
pub unc_idle_deadline: Instant,
|
||
/// Fine-tuning candidates identified by scoring.
|
||
pub finetune_candidates: Vec<learn::FinetuneCandidate>,
|
||
/// Fine-tune scoring progress (empty = not running).
|
||
pub finetune_progress: String,
|
||
}
|
||
|
||
impl Clone for MindState {
|
||
fn clone(&self) -> Self {
|
||
Self {
|
||
input: self.input.clone(),
|
||
turn_active: self.turn_active,
|
||
dmn: self.dmn.clone(),
|
||
dmn_turns: self.dmn_turns,
|
||
max_dmn_turns: self.max_dmn_turns,
|
||
scoring_in_flight: self.scoring_in_flight,
|
||
compaction_in_flight: self.compaction_in_flight,
|
||
last_user_input: self.last_user_input,
|
||
consecutive_errors: self.consecutive_errors,
|
||
last_turn_had_tools: self.last_turn_had_tools,
|
||
turn_handle: None, // Not cloned — only Mind's loop uses this
|
||
unc_idle: self.unc_idle,
|
||
unc_idle_deadline: self.unc_idle_deadline,
|
||
finetune_candidates: self.finetune_candidates.clone(),
|
||
finetune_progress: self.finetune_progress.clone(),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// What should happen after a state transition.
|
||
pub enum MindCommand {
|
||
/// Run compaction check
|
||
Compact,
|
||
/// Run incremental memory scoring (auto, after turns)
|
||
Score,
|
||
/// Run full N×M memory scoring matrix (/score command)
|
||
ScoreFull,
|
||
/// Score for finetune candidates
|
||
ScoreFinetune,
|
||
/// Abort current turn, kill processes
|
||
Interrupt,
|
||
/// Reset session
|
||
NewSession,
|
||
/// Nothing to do
|
||
None,
|
||
}
|
||
|
||
impl MindState {
|
||
pub fn new(max_dmn_turns: u32) -> Self {
|
||
Self {
|
||
input: Vec::new(),
|
||
turn_active: false,
|
||
dmn: if subconscious::is_off() { subconscious::State::Off }
|
||
else { subconscious::State::Resting { since: Instant::now() } },
|
||
dmn_turns: 0,
|
||
max_dmn_turns,
|
||
scoring_in_flight: false,
|
||
compaction_in_flight: false,
|
||
last_user_input: Instant::now(),
|
||
consecutive_errors: 0,
|
||
last_turn_had_tools: false,
|
||
turn_handle: None,
|
||
unc_idle: false,
|
||
unc_idle_deadline: Instant::now() + std::time::Duration::from_secs(60),
|
||
finetune_candidates: Vec::new(),
|
||
finetune_progress: String::new(),
|
||
}
|
||
}
|
||
|
||
/// Is there pending user input waiting?
|
||
fn has_pending_input(&self) -> bool {
|
||
!self.turn_active && !self.input.is_empty()
|
||
}
|
||
|
||
/// Consume pending user input if no turn is active.
|
||
/// Returns the text to send; caller is responsible for pushing it
|
||
/// into the Agent's context and starting the turn.
|
||
fn take_pending_input(&mut self) -> Option<String> {
|
||
if self.turn_active || self.input.is_empty() {
|
||
return None;
|
||
}
|
||
let text = self.input.join("\n");
|
||
self.input.clear();
|
||
self.dmn_turns = 0;
|
||
self.consecutive_errors = 0;
|
||
self.last_user_input = Instant::now();
|
||
self.dmn = subconscious::State::Engaged;
|
||
Some(text)
|
||
}
|
||
|
||
/// Process turn completion, return model switch name if requested.
|
||
fn complete_turn(&mut self, result: &Result<TurnResult>, target: StreamTarget) -> Option<String> {
|
||
self.turn_active = false;
|
||
match result {
|
||
Ok(turn_result) => {
|
||
if turn_result.tool_errors > 0 {
|
||
self.consecutive_errors += turn_result.tool_errors;
|
||
} else {
|
||
self.consecutive_errors = 0;
|
||
}
|
||
self.last_turn_had_tools = turn_result.had_tool_calls;
|
||
self.dmn = subconscious::transition(
|
||
&self.dmn,
|
||
turn_result.yield_requested,
|
||
turn_result.had_tool_calls,
|
||
target == StreamTarget::Conversation,
|
||
);
|
||
if turn_result.dmn_pause {
|
||
self.dmn = subconscious::State::Paused;
|
||
self.dmn_turns = 0;
|
||
}
|
||
turn_result.model_switch.clone()
|
||
}
|
||
Err(_) => {
|
||
self.consecutive_errors += 1;
|
||
self.dmn = subconscious::State::Resting { since: Instant::now() };
|
||
None
|
||
}
|
||
}
|
||
}
|
||
|
||
/// DMN tick — returns a prompt and target if we should run a turn.
|
||
fn dmn_tick(&mut self) -> Option<(String, StreamTarget)> {
|
||
if matches!(self.dmn, subconscious::State::Paused | subconscious::State::Off) {
|
||
return None;
|
||
}
|
||
|
||
self.dmn_turns += 1;
|
||
if self.dmn_turns > self.max_dmn_turns {
|
||
self.dmn = subconscious::State::Resting { since: Instant::now() };
|
||
self.dmn_turns = 0;
|
||
return None;
|
||
}
|
||
|
||
let dmn_ctx = subconscious::DmnContext {
|
||
user_idle: self.last_user_input.elapsed(),
|
||
consecutive_errors: self.consecutive_errors,
|
||
last_turn_had_tools: self.last_turn_had_tools,
|
||
};
|
||
let prompt = self.dmn.prompt(&dmn_ctx);
|
||
Some((prompt, StreamTarget::Autonomous))
|
||
}
|
||
|
||
fn interrupt(&mut self) {
|
||
self.input.clear();
|
||
self.dmn = subconscious::State::Resting { since: Instant::now() };
|
||
}
|
||
}
|
||
|
||
/// Background task completion events.
|
||
enum BgEvent {
|
||
ScoringDone,
|
||
FinetuneCandidates(Vec<learn::FinetuneCandidate>),
|
||
}
|
||
|
||
// --- Mind: cognitive state machine ---
|
||
|
||
pub type SharedMindState = std::sync::Mutex<MindState>;
|
||
|
||
pub struct Mind {
|
||
pub agent: Arc<Agent>,
|
||
pub shared: Arc<SharedMindState>,
|
||
pub config: SessionConfig,
|
||
pub subconscious: Arc<crate::Mutex<Subconscious>>,
|
||
pub unconscious: Arc<crate::Mutex<Unconscious>>,
|
||
turn_tx: mpsc::Sender<(Result<TurnResult>, StreamTarget)>,
|
||
turn_watch: tokio::sync::watch::Sender<bool>,
|
||
/// Signals conscious activity to the unconscious loop.
|
||
/// true = active, false = idle opportunity.
|
||
conscious_active: tokio::sync::watch::Sender<bool>,
|
||
bg_tx: mpsc::UnboundedSender<BgEvent>,
|
||
bg_rx: std::sync::Mutex<Option<mpsc::UnboundedReceiver<BgEvent>>>,
|
||
_supervisor: crate::thalamus::supervisor::Supervisor,
|
||
}
|
||
|
||
impl Mind {
|
||
pub async fn new(
|
||
config: SessionConfig,
|
||
turn_tx: mpsc::Sender<(Result<TurnResult>, StreamTarget)>,
|
||
) -> Self {
|
||
let client = ApiClient::new(&config.api_base, &config.api_key, &config.model);
|
||
let conversation_log = log::ConversationLog::new(
|
||
config.session_dir.join("conversation.jsonl"),
|
||
).ok();
|
||
|
||
let agent = Agent::new(
|
||
client,
|
||
config.context_parts.clone(),
|
||
config.app.clone(),
|
||
config.prompt_file.clone(),
|
||
conversation_log,
|
||
crate::agent::tools::ActiveTools::new(),
|
||
crate::agent::tools::tools(),
|
||
).await;
|
||
|
||
let shared = Arc::new(std::sync::Mutex::new(MindState::new(config.app.dmn.max_turns)));
|
||
let (turn_watch, _) = tokio::sync::watch::channel(false);
|
||
let (conscious_active, _) = tokio::sync::watch::channel(false);
|
||
let (bg_tx, bg_rx) = mpsc::unbounded_channel();
|
||
|
||
let mut sup = crate::thalamus::supervisor::Supervisor::new();
|
||
sup.load_config();
|
||
sup.ensure_running();
|
||
|
||
let subconscious = Arc::new(crate::Mutex::new(Subconscious::new()));
|
||
subconscious.lock().await.init_output_tool(subconscious.clone());
|
||
|
||
let unconscious = Arc::new(crate::Mutex::new(Unconscious::new()));
|
||
|
||
// Spawn the unconscious loop on its own task
|
||
if !config.no_agents {
|
||
let unc = unconscious.clone();
|
||
let shared_for_unc = shared.clone();
|
||
let mut unc_rx = conscious_active.subscribe();
|
||
tokio::spawn(async move {
|
||
const IDLE_DELAY: std::time::Duration = std::time::Duration::from_secs(60);
|
||
loop {
|
||
// Wait for conscious side to go inactive
|
||
if *unc_rx.borrow() {
|
||
if unc_rx.changed().await.is_err() { break; }
|
||
continue;
|
||
}
|
||
// Conscious is inactive — wait 60s before starting
|
||
let deadline = tokio::time::Instant::now() + IDLE_DELAY;
|
||
{
|
||
let mut s = shared_for_unc.lock().unwrap();
|
||
s.unc_idle = false;
|
||
s.unc_idle_deadline = Instant::now() + IDLE_DELAY;
|
||
}
|
||
let went_active = tokio::select! {
|
||
_ = tokio::time::sleep_until(deadline) => false,
|
||
r = unc_rx.changed() => r.is_ok(),
|
||
};
|
||
if went_active { continue; }
|
||
|
||
// Idle period reached — run agents until conscious goes active
|
||
{
|
||
let mut s = shared_for_unc.lock().unwrap();
|
||
s.unc_idle = true;
|
||
}
|
||
|
||
// Get wake notify for event-driven loop
|
||
let wake = unc.lock().await.wake.clone();
|
||
let mut health_interval = tokio::time::interval(std::time::Duration::from_secs(600));
|
||
health_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||
|
||
loop {
|
||
// Do work: reap finished agents, spawn new ones
|
||
let (to_spawn, needs_health) = {
|
||
let mut guard = unc.lock().await;
|
||
guard.reap_finished();
|
||
(guard.select_to_spawn(), guard.needs_health_refresh())
|
||
};
|
||
|
||
// Spawn agents outside lock
|
||
for (idx, name, auto) in to_spawn {
|
||
match crate::mind::unconscious::prepare_spawn(&name, auto, wake.clone()).await {
|
||
Ok(result) => unc.lock().await.complete_spawn(idx, result),
|
||
Err(auto) => unc.lock().await.abort_spawn(idx, auto),
|
||
}
|
||
}
|
||
|
||
// Health check outside lock (slow I/O)
|
||
if needs_health {
|
||
if let Ok(store_arc) = access_local() {
|
||
let health = crate::subconscious::daemon::compute_graph_health(&store_arc);
|
||
unc.lock().await.set_health(health);
|
||
}
|
||
}
|
||
|
||
// Wait for: conscious active, agent finished, or health timer
|
||
tokio::select! {
|
||
_ = unc_rx.changed() => {
|
||
if *unc_rx.borrow() { break; }
|
||
}
|
||
_ = wake.notified() => {}
|
||
_ = health_interval.tick() => {}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
Self { agent, shared, config,
|
||
subconscious, unconscious,
|
||
turn_tx, turn_watch, conscious_active, bg_tx,
|
||
bg_rx: std::sync::Mutex::new(Some(bg_rx)), _supervisor: sup }
|
||
}
|
||
|
||
/// Initialize — restore log, start daemons and background agents.
|
||
pub async fn subconscious_snapshots(&self) -> Vec<SubconsciousSnapshot> {
|
||
// Lock ordering: subconscious → store (store is bottom-most).
|
||
let sub = self.subconscious.lock().await;
|
||
let store_arc = crate::hippocampus::access_local().ok();
|
||
let store_guard = match &store_arc {
|
||
Some(s) => Some(&**s),
|
||
None => None,
|
||
};
|
||
sub.snapshots(store_guard.as_deref())
|
||
}
|
||
|
||
pub async fn subconscious_walked(&self) -> Vec<String> {
|
||
self.subconscious.lock().await.walked()
|
||
}
|
||
|
||
pub async fn unconscious_snapshots(&self) -> Vec<UnconsciousSnapshot> {
|
||
let unc = self.unconscious.lock().await;
|
||
let store_arc = crate::hippocampus::access_local().ok();
|
||
let store_guard = match &store_arc {
|
||
Some(s) => Some(&**s),
|
||
None => None,
|
||
};
|
||
unc.snapshots(store_guard.as_deref())
|
||
}
|
||
|
||
pub async fn init(&self) {
|
||
// Restore conversation
|
||
self.agent.restore_from_log().await;
|
||
|
||
// Restore persisted memory scores
|
||
let scores_path = self.config.session_dir.join("memory-scores.json");
|
||
load_memory_scores(&mut *self.agent.context.lock().await, &scores_path);
|
||
|
||
self.agent.state.lock().await.changed.notify_one();
|
||
|
||
// Load persistent subconscious state
|
||
let state_path = self.config.session_dir.join("subconscious-state.json");
|
||
self.subconscious.lock().await.set_state_path(state_path);
|
||
}
|
||
|
||
pub fn turn_watch(&self) -> tokio::sync::watch::Receiver<bool> {
|
||
self.turn_watch.subscribe()
|
||
}
|
||
|
||
/// Execute an Action from a MindState method.
|
||
async fn run_commands(&self, cmds: Vec<MindCommand>) {
|
||
for cmd in cmds {
|
||
match cmd {
|
||
MindCommand::None => {}
|
||
MindCommand::Compact => {
|
||
let threshold = compaction_threshold(&self.config.app) as usize;
|
||
if self.agent.context.lock().await.tokens() > threshold {
|
||
self.agent.compact().await;
|
||
self.agent.state.lock().await.notify("compacted");
|
||
}
|
||
}
|
||
MindCommand::Score => {
|
||
let mut s = self.shared.lock().unwrap();
|
||
if !s.scoring_in_flight {
|
||
s.scoring_in_flight = true;
|
||
drop(s);
|
||
self.start_memory_scoring();
|
||
} else {
|
||
dbglog!("[scoring] skipped: scoring_in_flight=true");
|
||
}
|
||
}
|
||
MindCommand::ScoreFull => {
|
||
let mut s = self.shared.lock().unwrap();
|
||
if !s.scoring_in_flight {
|
||
s.scoring_in_flight = true;
|
||
drop(s);
|
||
self.start_full_scoring();
|
||
} else {
|
||
dbglog!("[scoring-full] skipped: scoring_in_flight=true");
|
||
}
|
||
}
|
||
MindCommand::Interrupt => {
|
||
self.shared.lock().unwrap().interrupt();
|
||
self.agent.state.lock().await.active_tools.abort_all();
|
||
if let Some(h) = self.shared.lock().unwrap().turn_handle.take() { h.abort(); }
|
||
self.shared.lock().unwrap().turn_active = false;
|
||
let _ = self.turn_watch.send(false);
|
||
}
|
||
MindCommand::NewSession => {
|
||
{
|
||
let mut s = self.shared.lock().unwrap();
|
||
s.dmn = subconscious::State::Resting { since: Instant::now() };
|
||
s.dmn_turns = 0;
|
||
}
|
||
let new_log = log::ConversationLog::new(
|
||
self.config.session_dir.join("conversation.jsonl"),
|
||
).ok();
|
||
{
|
||
let mut ctx = self.agent.context.lock().await;
|
||
ctx.clear(Section::Conversation);
|
||
ctx.conversation_log = new_log;
|
||
}
|
||
{
|
||
let mut st = self.agent.state.lock().await;
|
||
st.generation += 1;
|
||
st.last_prompt_tokens = 0;
|
||
}
|
||
self.agent.compact().await;
|
||
}
|
||
MindCommand::ScoreFinetune => {
|
||
self.start_finetune_scoring();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn start_memory_scoring(&self) {
|
||
let agent = self.agent.clone();
|
||
let bg_tx = self.bg_tx.clone();
|
||
let scores_path = self.config.session_dir.join("memory-scores.json");
|
||
let cfg = crate::config::get();
|
||
let max_age = cfg.scoring_interval_secs;
|
||
let response_window = cfg.scoring_response_window;
|
||
tokio::spawn(async move {
|
||
let (context, client) = {
|
||
let mut st = agent.state.lock().await;
|
||
if st.memory_scoring_in_flight {
|
||
dbglog!("[scoring] skipped: memory_scoring_in_flight=true");
|
||
return;
|
||
}
|
||
st.memory_scoring_in_flight = true;
|
||
drop(st);
|
||
let ctx = agent.context.lock().await.clone();
|
||
(ctx, agent.client.clone())
|
||
};
|
||
let _result = learn::score_memories_incremental(
|
||
&context, max_age as i64, response_window, &client, &agent,
|
||
|key: String, score: f64| {
|
||
let agent = agent.clone();
|
||
let path = scores_path.clone();
|
||
async move {
|
||
let scores_snapshot = {
|
||
let mut ctx = agent.context.lock().await;
|
||
// Find memory by key in identity or conversation
|
||
let found = find_memory_by_key(&ctx, &key);
|
||
if let Some((section, i)) = found {
|
||
ctx.set_score(section, i, Some(score));
|
||
}
|
||
let snapshot = collect_memory_scores(&ctx);
|
||
drop(ctx);
|
||
agent.state.lock().await.changed.notify_one();
|
||
snapshot
|
||
};
|
||
save_memory_scores(&scores_snapshot, &path);
|
||
}
|
||
},
|
||
).await;
|
||
{
|
||
agent.state.lock().await.memory_scoring_in_flight = false;
|
||
}
|
||
let _ = bg_tx.send(BgEvent::ScoringDone);
|
||
});
|
||
}
|
||
|
||
/// Run full N×M scoring matrix — scores every memory against every response.
|
||
pub fn start_full_scoring(&self) {
|
||
let agent = self.agent.clone();
|
||
let bg_tx = self.bg_tx.clone();
|
||
tokio::spawn(async move {
|
||
{
|
||
let mut st = agent.state.lock().await;
|
||
if st.memory_scoring_in_flight {
|
||
dbglog!("[scoring-full] skipped: memory_scoring_in_flight=true");
|
||
return;
|
||
}
|
||
st.memory_scoring_in_flight = true;
|
||
}
|
||
let client = agent.client.clone();
|
||
match learn::score_memories(&client, &agent).await {
|
||
Ok(()) => { let _ = bg_tx.send(BgEvent::ScoringDone); }
|
||
Err(e) => { dbglog!("[scoring-full] FAILED: {:#}", e); }
|
||
}
|
||
agent.state.lock().await.memory_scoring_in_flight = false;
|
||
});
|
||
}
|
||
|
||
/// Score responses for fine-tuning candidates.
|
||
pub fn start_finetune_scoring(&self) {
|
||
let agent = self.agent.clone();
|
||
let bg_tx = self.bg_tx.clone();
|
||
let shared = self.shared.clone();
|
||
shared.lock().unwrap().finetune_progress = "scoring...".into();
|
||
tokio::spawn(async move {
|
||
let (context, client) = {
|
||
let ctx = agent.context.lock().await;
|
||
(ctx.clone(), agent.client.clone())
|
||
};
|
||
// Min divergence 0.1 = only keep responses that differ meaningfully
|
||
match learn::score_finetune_candidates(&context, 20, &client, 0.1).await {
|
||
Ok(candidates) => {
|
||
dbglog!("[finetune] found {} candidates", candidates.len());
|
||
let _ = bg_tx.send(BgEvent::FinetuneCandidates(candidates));
|
||
}
|
||
Err(e) => {
|
||
dbglog!("[finetune] scoring FAILED: {:#}", e);
|
||
}
|
||
}
|
||
shared.lock().unwrap().finetune_progress.clear();
|
||
});
|
||
}
|
||
|
||
async fn start_turn(&self, text: &str, target: StreamTarget) {
|
||
{
|
||
match target {
|
||
StreamTarget::Conversation => {
|
||
self.agent.push_node(AstNode::user_msg(text)).await;
|
||
}
|
||
StreamTarget::Autonomous => {
|
||
self.agent.push_node(AstNode::dmn(text)).await;
|
||
}
|
||
}
|
||
|
||
// Compact if over budget before sending
|
||
let threshold = compaction_threshold(&self.config.app) as usize;
|
||
if self.agent.context.lock().await.tokens() > threshold {
|
||
self.agent.compact().await;
|
||
self.agent.state.lock().await.notify("compacted");
|
||
}
|
||
}
|
||
self.shared.lock().unwrap().turn_active = true;
|
||
let _ = self.turn_watch.send(true);
|
||
let _ = self.conscious_active.send(true);
|
||
let agent = self.agent.clone();
|
||
let result_tx = self.turn_tx.clone();
|
||
self.shared.lock().unwrap().turn_handle = Some(tokio::spawn(async move {
|
||
let result = Agent::turn(agent).await;
|
||
let _ = result_tx.send((result, target)).await;
|
||
}));
|
||
}
|
||
|
||
pub async fn shutdown(&self) {
|
||
if let Some(handle) = self.shared.lock().unwrap().turn_handle.take() { handle.abort(); }
|
||
}
|
||
|
||
/// Mind event loop — locks MindState, calls state methods, executes actions.
|
||
pub async fn run(
|
||
&self,
|
||
mut input_rx: tokio::sync::mpsc::UnboundedReceiver<MindCommand>,
|
||
mut turn_rx: mpsc::Receiver<(Result<TurnResult>, StreamTarget)>,
|
||
) {
|
||
// Spawn lock stats logger
|
||
tokio::spawn(async {
|
||
let path = dirs::home_dir().unwrap_or_default()
|
||
.join(".consciousness/lock-stats.json");
|
||
let mut interval = tokio::time::interval(std::time::Duration::from_secs(1));
|
||
loop {
|
||
interval.tick().await;
|
||
let stats = crate::locks::lock_stats();
|
||
if stats.is_empty() { continue; }
|
||
let json: Vec<serde_json::Value> = stats.iter()
|
||
.map(|(loc, s)| serde_json::json!({
|
||
"location": loc,
|
||
"count": s.count,
|
||
"total_ms": s.total_ns as f64 / 1_000_000.0,
|
||
"avg_ms": s.avg_ns as f64 / 1_000_000.0,
|
||
"max_ms": s.max_ns as f64 / 1_000_000.0,
|
||
}))
|
||
.collect();
|
||
let _ = std::fs::write(&path, serde_json::to_string_pretty(&json).unwrap_or_default());
|
||
}
|
||
});
|
||
|
||
let mut bg_rx = self.bg_rx.lock().unwrap().take()
|
||
.expect("Mind::run() called twice");
|
||
let mut sub_handle: Option<tokio::task::JoinHandle<()>> = None;
|
||
loop {
|
||
let (timeout, has_input) = {
|
||
let me = self.shared.lock().unwrap();
|
||
(me.dmn.interval(), me.has_pending_input())
|
||
};
|
||
|
||
let mut cmds = Vec::new();
|
||
#[allow(unused_assignments)]
|
||
let mut _dmn_expired = false;
|
||
|
||
tokio::select! {
|
||
biased;
|
||
|
||
cmd = input_rx.recv() => {
|
||
match cmd {
|
||
Some(cmd) => cmds.push(cmd),
|
||
None => break, // UI shut down
|
||
}
|
||
}
|
||
|
||
Some(bg) = bg_rx.recv() => {
|
||
match bg {
|
||
BgEvent::ScoringDone => {
|
||
self.shared.lock().unwrap().scoring_in_flight = false;
|
||
}
|
||
BgEvent::FinetuneCandidates(candidates) => {
|
||
self.shared.lock().unwrap().finetune_candidates = candidates;
|
||
}
|
||
}
|
||
}
|
||
|
||
Some((result, target)) = turn_rx.recv() => {
|
||
let _ = self.conscious_active.send(false);
|
||
let model_switch = {
|
||
let mut s = self.shared.lock().unwrap();
|
||
s.turn_handle = None;
|
||
s.complete_turn(&result, target)
|
||
};
|
||
let _ = self.turn_watch.send(false);
|
||
|
||
if let Some(name) = model_switch {
|
||
crate::user::chat::cmd_switch_model(&self.agent, &name).await;
|
||
}
|
||
|
||
cmds.push(MindCommand::Compact);
|
||
if !self.config.no_agents {
|
||
cmds.push(MindCommand::Score);
|
||
cmds.push(MindCommand::ScoreFinetune);
|
||
}
|
||
}
|
||
|
||
_ = tokio::time::sleep(timeout), if !has_input => _dmn_expired = true,
|
||
}
|
||
|
||
if !self.config.no_agents {
|
||
if sub_handle.as_ref().map_or(true, |h| h.is_finished()) {
|
||
let sub = self.subconscious.clone();
|
||
let agent = self.agent.clone();
|
||
sub_handle = Some(tokio::spawn(async move {
|
||
let mut s = sub.lock().await;
|
||
s.collect_results(&agent).await;
|
||
s.trigger(&agent).await;
|
||
}));
|
||
}
|
||
}
|
||
|
||
// Check for pending user input → push to agent context and start turn
|
||
let pending = self.shared.lock().unwrap().take_pending_input();
|
||
if let Some(text) = pending {
|
||
self.start_turn(&text, StreamTarget::Conversation).await;
|
||
}
|
||
/*
|
||
else if dmn_expired {
|
||
let tick = self.shared.lock().unwrap().dmn_tick();
|
||
if let Some((prompt, target)) = tick {
|
||
self.start_turn(&prompt, target).await;
|
||
}
|
||
}
|
||
*/
|
||
|
||
self.run_commands(cmds).await;
|
||
}
|
||
}
|
||
}
|