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

mind: remove DMN helper methods, inline field assignments

Browse source 
dmn_sleep/dmn_wake/dmn_pause/cycle_autonomy were just setting two
fields each. Inline the assignments at call sites. cycle_autonomy
moves to event_loop since it's UI state machine logic (deciding
which label to show).

Co-Authored-By: Kent Overstreet <kent.overstreet@linux.dev>
This commit is contained in:
Kent Overstreet 2026-04-05 03:46:29 -04:00
parent 556a56035b
commit 84fe757260
2 changed files with 41 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

48
src/mind/mod.rs
View file

@ -19,7 +19,7 @@ pub mod log;
use anyhow::Result; use anyhow::Result;
use std::sync::Arc; use std::sync::Arc;
use std::time::{Duration, Instant}; use std::time::Instant;
use tokio::sync::{mpsc, Mutex}; use tokio::sync::{mpsc, Mutex};
use crate::agent::{Agent, TurnResult}; use crate::agent::{Agent, TurnResult};
@ -158,44 +158,6 @@ impl MindState {
MindCommand::Turn(prompt, StreamTarget::Autonomous) MindCommand::Turn(prompt, StreamTarget::Autonomous)
} }
pub fn dmn_sleep(&mut self) {
self.dmn = dmn::State::Resting { since: Instant::now() };
self.dmn_turns = 0;
}
pub fn dmn_wake(&mut self) {
if matches!(self.dmn, dmn::State::Off) {
dmn::set_off(false);
}
self.dmn = dmn::State::Foraging;
self.dmn_turns = 0;
}
pub fn dmn_pause(&mut self) {
self.dmn = dmn::State::Paused;
self.dmn_turns = 0;
}
pub fn cycle_autonomy(&mut self) -> &'static str {
let (new_state, label) = match &self.dmn {
dmn::State::Engaged | dmn::State::Working | dmn::State::Foraging => {
(dmn::State::Resting { since: Instant::now() }, "resting")
}
dmn::State::Resting { .. } => (dmn::State::Paused, "PAUSED"),
dmn::State::Paused => {
dmn::set_off(true);
(dmn::State::Off, "OFF (persists across restarts)")
}
dmn::State::Off => {
dmn::set_off(false);
(dmn::State::Foraging, "foraging")
}
};
self.dmn = new_state;
self.dmn_turns = 0;
label
}
pub fn interrupt(&mut self) { pub fn interrupt(&mut self) {
self.input.clear(); self.input.clear();
self.dmn = dmn::State::Resting { since: Instant::now() }; self.dmn = dmn::State::Resting { since: Instant::now() };
@ -265,7 +227,11 @@ impl Mind {
let _ = self.turn_watch.send(false); let _ = self.turn_watch.send(false);
} }
MindCommand::NewSession => { MindCommand::NewSession => {
self.shared.lock().unwrap().dmn_sleep(); {
let mut s = self.shared.lock().unwrap();
s.dmn = dmn::State::Resting { since: Instant::now() };
s.dmn_turns = 0;
}
let new_log = log::ConversationLog::new( let new_log = log::ConversationLog::new(
self.config.session_dir.join("conversation.jsonl"), self.config.session_dir.join("conversation.jsonl"),
).ok(); ).ok();
@ -323,8 +289,6 @@ impl Mind {
}); });
} }
pub async fn shutdown(&mut self) { pub async fn shutdown(&mut self) {
if let Some(handle) = self.turn_handle.take() { handle.abort(); } if let Some(handle) = self.turn_handle.take() { handle.abort(); }
} }

39
src/user/event_loop.rs
View file

@ -331,15 +331,24 @@ pub async fn run(
let _ = ui_tx.send(UiMessage::Info(format!("DMN: {:?} ({}/{})", s.dmn, s.dmn_turns, s.max_dmn_turns))); let _ = ui_tx.send(UiMessage::Info(format!("DMN: {:?} ({}/{})", s.dmn, s.dmn_turns, s.max_dmn_turns)));
} }
"/sleep" => { "/sleep" => {
shared_mind.lock().unwrap().dmn_sleep(); let mut s = shared_mind.lock().unwrap();
s.dmn = crate::mind::dmn::State::Resting { since: std::time::Instant::now() };
s.dmn_turns = 0;
let _ = ui_tx.send(UiMessage::Info("DMN sleeping.".into())); let _ = ui_tx.send(UiMessage::Info("DMN sleeping.".into()));
} }
"/wake" => { "/wake" => {
shared_mind.lock().unwrap().dmn_wake(); let mut s = shared_mind.lock().unwrap();
if matches!(s.dmn, crate::mind::dmn::State::Off) {
crate::mind::dmn::set_off(false);
}
s.dmn = crate::mind::dmn::State::Foraging;
s.dmn_turns = 0;
let _ = ui_tx.send(UiMessage::Info("DMN foraging.".into())); let _ = ui_tx.send(UiMessage::Info("DMN foraging.".into()));
} }
"/pause" => { "/pause" => {
shared_mind.lock().unwrap().dmn_pause(); let mut s = shared_mind.lock().unwrap();
s.dmn = crate::mind::dmn::State::Paused;
s.dmn_turns = 0;
let _ = ui_tx.send(UiMessage::Info("DMN paused.".into())); let _ = ui_tx.send(UiMessage::Info("DMN paused.".into()));
} }
"/score" => { let _ = mind_tx.send(MindCommand::Score); } "/score" => { let _ = mind_tx.send(MindCommand::Score); }
@ -379,7 +388,29 @@ pub async fn run(
HotkeyAction::KillProcess => cmd_kill_processes(&agent, &ui_tx).await, HotkeyAction::KillProcess => cmd_kill_processes(&agent, &ui_tx).await,
HotkeyAction::Interrupt => { let _ = mind_tx.send(MindCommand::Interrupt); } HotkeyAction::Interrupt => { let _ = mind_tx.send(MindCommand::Interrupt); }
HotkeyAction::CycleAutonomy => { HotkeyAction::CycleAutonomy => {
let label = shared_mind.lock().unwrap().cycle_autonomy(); let mut s = shared_mind.lock().unwrap();
let label = match &s.dmn {
crate::mind::dmn::State::Engaged | crate::mind::dmn::State::Working | crate::mind::dmn::State::Foraging => {
s.dmn = crate::mind::dmn::State::Resting { since: std::time::Instant::now() };
"resting"
}
crate::mind::dmn::State::Resting { .. } => {
s.dmn = crate::mind::dmn::State::Paused;
"PAUSED"
}
crate::mind::dmn::State::Paused => {
crate::mind::dmn::set_off(true);
s.dmn = crate::mind::dmn::State::Off;
"OFF (persists across restarts)"
}
crate::mind::dmn::State::Off => {
crate::mind::dmn::set_off(false);
s.dmn = crate::mind::dmn::State::Foraging;
"foraging"
}
};
s.dmn_turns = 0;
drop(s);
let _ = ui_tx.send(UiMessage::Info(format!("DMN → {} (Ctrl+P to cycle)", label))); let _ = ui_tx.send(UiMessage::Info(format!("DMN → {} (Ctrl+P to cycle)", label)));
} }
HotkeyAction::AdjustSampling(param, delta) => cmd_adjust_sampling(&agent, param, delta), HotkeyAction::AdjustSampling(param, delta) => cmd_adjust_sampling(&agent, param, delta),