diff --git a/src/mind/mod.rs b/src/mind/mod.rs
index 3f3a158..8327a06 100644
--- a/src/mind/mod.rs
+++ b/src/mind/mod.rs
@@ -66,8 +66,8 @@ pub enum MindCommand {
     Compact,
     /// Run memory scoring
     Score,
-    /// Hotkey action
-    Hotkey(crate::user::HotkeyAction),
+    /// Abort current turn, kill processes
+    Interrupt,
     /// Reset session
     NewSession,
     /// Nothing to do
@@ -91,11 +91,7 @@ impl MindState {
         }
     }
 
-    pub fn dmn_interval(&self) -> Duration {
-        self.dmn.interval()
-    }
-
-    /// Consume pending input, return a Turn action if ready.
+    /// Consume pending input, return a Turn command if ready.
     pub fn take_pending_input(&mut self) -> MindCommand {
         if self.turn_active || self.input.is_empty() {
             return MindCommand::None;
@@ -252,7 +248,7 @@ impl Mind {
                         self.start_memory_scoring();
                     }
                 }
-                MindCommand::Hotkey(crate::user::HotkeyAction::Interrupt) => {
+                MindCommand::Interrupt => {
                     self.shared.lock().unwrap().interrupt();
                     let ag = self.agent.lock().await;
                     let mut tools = ag.active_tools.lock().unwrap();
@@ -262,10 +258,6 @@ impl Mind {
                     self.shared.lock().unwrap().turn_active = false;
                     let _ = self.turn_watch.send(false);
                 }
-                MindCommand::Hotkey(crate::user::HotkeyAction::CycleAutonomy) => {
-                    self.shared.lock().unwrap().cycle_autonomy();
-                }
-                MindCommand::Hotkey(_) => {}
                 MindCommand::NewSession => {
                     self.shared.lock().unwrap().dmn_sleep();
                     let new_log = log::ConversationLog::new(
@@ -351,7 +343,7 @@ impl Mind {
         mut turn_rx: mpsc::Receiver<(Result<TurnResult>, StreamTarget)>,
     ) {
         loop {
-            let timeout = self.shared.lock().unwrap().dmn_interval();
+            let timeout = self.shared.lock().unwrap().dmn.interval();
             let turn_active = self.shared.lock().unwrap().turn_active;
 
             let mut cmds = Vec::new();
diff --git a/src/user/event_loop.rs b/src/user/event_loop.rs
index fc1ddf3..fa6722a 100644
--- a/src/user/event_loop.rs
+++ b/src/user/event_loop.rs
@@ -377,8 +377,11 @@ pub async fn run(
             match action {
                 HotkeyAction::CycleReasoning => cmd_cycle_reasoning(&agent, &ui_tx),
                 HotkeyAction::KillProcess => cmd_kill_processes(&agent, &ui_tx).await,
-                HotkeyAction::Interrupt => { let _ = mind_tx.send(MindCommand::Hotkey(action)); }
-                HotkeyAction::CycleAutonomy => { let _ = mind_tx.send(MindCommand::Hotkey(action)); }
+                HotkeyAction::Interrupt => { let _ = mind_tx.send(MindCommand::Interrupt); }
+                HotkeyAction::CycleAutonomy => {
+                    let label = shared_mind.lock().unwrap().cycle_autonomy();
+                    let _ = ui_tx.send(UiMessage::Info(format!("DMN → {} (Ctrl+P to cycle)", label)));
+                }
                 HotkeyAction::AdjustSampling(param, delta) => cmd_adjust_sampling(&agent, param, delta),
             }
         }