diff --git a/src/mind/mod.rs b/src/mind/mod.rs
index ecc4192..032b4cb 100644
--- a/src/mind/mod.rs
+++ b/src/mind/mod.rs
@@ -19,7 +19,7 @@ pub mod log;
 
 use anyhow::Result;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Instant;
 use tokio::sync::{mpsc, Mutex};
 
 use crate::agent::{Agent, TurnResult};
@@ -158,44 +158,6 @@ impl MindState {
         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) {
         self.input.clear();
         self.dmn = dmn::State::Resting { since: Instant::now() };
@@ -265,7 +227,11 @@ impl Mind {
                     let _ = self.turn_watch.send(false);
                 }
                 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(
                         self.config.session_dir.join("conversation.jsonl"),
                     ).ok();
@@ -323,8 +289,6 @@ impl Mind {
         });
     }
 
-
-
     pub async fn shutdown(&mut self) {
         if let Some(handle) = self.turn_handle.take() { handle.abort(); }
     }
diff --git a/src/user/event_loop.rs b/src/user/event_loop.rs
index fa6722a..e7b2805 100644
--- a/src/user/event_loop.rs
+++ b/src/user/event_loop.rs
@@ -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)));
                 }
                 "/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()));
                 }
                 "/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()));
                 }
                 "/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()));
                 }
                 "/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::Interrupt => { let _ = mind_tx.send(MindCommand::Interrupt); }
                 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)));
                 }
                 HotkeyAction::AdjustSampling(param, delta) => cmd_adjust_sampling(&agent, param, delta),