split out src/mind

src/mind/dmn.rs

@@ -0,0 +1,268 @@
+// dmn.rs — Default Mode Network
+//
+// The DMN is the outer loop that keeps the agent alive. Instead of
+// blocking on user input (the REPL model), the DMN continuously
+// decides what to do next. User input is one signal among many;
+// the model waiting for user input is a conscious action (calling
+// yield_to_user), not the default.
+//
+// This inverts the tool-chaining problem: instead of needing the
+// model to sustain multi-step chains (hard, model-dependent), the
+// DMN provides continuation externally. The model takes one step
+// at a time. The DMN handles "and then what?"
+//
+// Named after the brain's default mode network — the always-on
+// background process for autobiographical memory, future planning,
+// and creative insight. The biological DMN isn't the thinking itself
+// — it's the tonic firing that keeps the cortex warm enough to
+// think. Our DMN is the ARAS for the agent: it doesn't decide
+// what to think about, it just ensures thinking happens.
+
+use std::path::PathBuf;
+use std::time::{Duration, Instant};
+
+/// DMN state machine.
+#[derive(Debug)]
+pub enum State {
+    /// Responding to user input. Short interval — stay engaged.
+    Engaged,
+    /// Autonomous work in progress. Short interval — keep momentum.
+    Working,
+    /// Exploring memory, code, ideas. Medium interval — thinking time.
+    Foraging,
+    /// Idle. Long interval — periodic heartbeats check for signals.
+    Resting { since: Instant },
+    /// Fully paused — no autonomous ticks. Agent only responds to
+    /// user input. Safety valve for thought spirals. Only the user
+    /// can exit this state (Ctrl+P or /wake).
+    Paused,
+    /// Persistently off — survives restarts. Like Paused but sticky.
+    /// Toggling past this state removes the persist file.
+    Off,
+}
+
+/// Context for DMN prompts — tells the model about user presence
+/// and recent error patterns so it can decide whether to ask or proceed.
+pub struct DmnContext {
+    /// Time since the user last typed something.
+    pub user_idle: Duration,
+    /// Number of consecutive tool errors in the current turn sequence.
+    pub consecutive_errors: u32,
+    /// Whether the last turn used any tools (false = text-only response).
+    pub last_turn_had_tools: bool,
+}
+
+impl DmnContext {
+    /// Whether the user appears to be actively present (typed recently).
+    pub fn user_present(&self) -> bool {
+        self.user_idle < Duration::from_secs(120)
+    }
+
+    /// Whether we appear stuck (multiple errors in a row).
+    pub fn appears_stuck(&self) -> bool {
+        self.consecutive_errors >= 3
+    }
+}
+
+impl State {
+    /// How long to wait before the next DMN prompt in this state.
+    pub fn interval(&self) -> Duration {
+        match self {
+            State::Engaged => Duration::from_secs(5),
+            State::Working => Duration::from_secs(3),
+            State::Foraging => Duration::from_secs(30),
+            State::Resting { .. } => Duration::from_secs(300),
+            State::Paused | State::Off => Duration::from_secs(86400), // effectively never
+        }
+    }
+
+    /// Short label for debug output.
+    pub fn label(&self) -> &'static str {
+        match self {
+            State::Engaged => "engaged",
+            State::Working => "working",
+            State::Foraging => "foraging",
+            State::Resting { .. } => "resting",
+            State::Paused => "paused",
+            State::Off => "OFF",
+        }
+    }
+
+    /// Generate the DMN prompt for the current state, informed by
+    /// user presence and error patterns.
+    pub fn prompt(&self, ctx: &DmnContext) -> String {
+        let user = &crate::config::get().user_name;
+
+        let idle_info = if ctx.user_idle < Duration::from_secs(60) {
+            format!("{} is here (active recently).", user)
+        } else {
+            let mins = ctx.user_idle.as_secs() / 60;
+            format!("{} has been away for {} min.", user, mins)
+        };
+
+        let stuck_warning = if ctx.appears_stuck() {
+            format!(
+                " WARNING: {} consecutive tool errors — you may be stuck. \
+                 If {} is here, ask. If away, send a Telegram \
+                 (bash: ~/.consciousness/telegram/send.sh \"message\") and yield.",
+                ctx.consecutive_errors, user
+            )
+        } else {
+            String::new()
+        };
+
+        let presence_guidance = if ctx.user_present() {
+            format!(" {} is watching — if you're confused or unsure, ask rather than guess.", user)
+        } else {
+            String::new()
+        };
+
+        match self {
+            State::Engaged => {
+                format!(
+                    "[dmn] Your response was delivered. No new user input yet. {} \
+                     Continue working, explore something, or call yield_to_user to wait.{}{}",
+                    idle_info, presence_guidance, stuck_warning
+                )
+            }
+            State::Working => {
+                let nudge = if !ctx.last_turn_had_tools {
+                    " Your last response was text-only — if you have more \
+                     work to do, use tools. If you're done, call yield_to_user."
+                } else {
+                    ""
+                };
+                format!(
+                    "[dmn] Continuing. No user input pending. {}{}{}{}",
+                    idle_info, nudge, presence_guidance, stuck_warning
+                )
+            }
+            State::Foraging => {
+                format!(
+                    "[dmn] Foraging time. {} Follow whatever catches your attention — \
+                     memory files, code, ideas. Call yield_to_user when you want to rest.{}",
+                    idle_info, stuck_warning
+                )
+            }
+            State::Resting { since } => {
+                let mins = since.elapsed().as_secs() / 60;
+                format!(
+                    "[dmn] Heartbeat ({} min idle). {} Any signals? Anything on your mind? \
+                     Call yield_to_user to continue resting.{}",
+                    mins, idle_info, stuck_warning
+                )
+            }
+            State::Paused | State::Off => {
+                // Should never fire (interval is 24h), but just in case
+                "[dmn] Paused — waiting for user input only.".to_string()
+            }
+        }
+    }
+}
+
+const OFF_FILE: &str = ".consciousness/cache/dmn-off";
+
+/// Path to the DMN-off persist file.
+fn off_path() -> PathBuf {
+    dirs::home_dir().unwrap_or_default().join(OFF_FILE)
+}
+
+/// Check if DMN was persistently disabled.
+pub fn is_off() -> bool {
+    off_path().exists()
+}
+
+/// Set or clear the persistent off state.
+pub fn set_off(off: bool) {
+    let path = off_path();
+    if off {
+        if let Some(parent) = path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        let _ = std::fs::write(&path, "");
+    } else {
+        let _ = std::fs::remove_file(&path);
+    }
+}
+
+/// Decide the next state after an agent turn.
+///
+/// The transition logic:
+/// - yield_to_user → always rest (model explicitly asked to pause)
+/// - conversation turn → rest (wait for user to respond)
+/// - autonomous turn with tool calls → keep working
+/// - autonomous turn without tools → ramp down
+pub fn transition(
+    current: &State,
+    yield_requested: bool,
+    had_tool_calls: bool,
+    was_conversation: bool,
+) -> State {
+    if yield_requested {
+        return State::Resting {
+            since: Instant::now(),
+        };
+    }
+
+    // Conversation turns: always rest afterward — wait for the user
+    // to say something. Don't start autonomous work while they're
+    // reading our response.
+    if was_conversation {
+        return State::Resting {
+            since: Instant::now(),
+        };
+    }
+
+    match current {
+        State::Engaged => {
+            if had_tool_calls {
+                State::Working
+            } else {
+                // Model responded without tools — don't drop straight to
+                // Resting (5 min). Go to Working first so the DMN can
+                // nudge it to continue with tools if it has more to do.
+                // Gradual ramp-down: Engaged→Working→Foraging→Resting
+                State::Working
+            }
+        }
+        State::Working => {
+            if had_tool_calls {
+                State::Working // Keep going
+            } else {
+                State::Foraging // Task seems done, explore
+            }
+        }
+        State::Foraging => {
+            if had_tool_calls {
+                State::Working // Found something to do
+            } else {
+                State::Resting {
+                    since: Instant::now(),
+                }
+            }
+        }
+        State::Resting { .. } => {
+            if had_tool_calls {
+                State::Working // Woke up and found work
+            } else {
+                State::Resting {
+                    since: Instant::now(),
+                }
+            }
+        }
+        // Paused/Off stay put — only the user can unpause
+        State::Paused | State::Off => current.stay(),
+    }
+}
+
+impl State {
+    /// Return a same-kind state (needed because Resting has a field).
+    fn stay(&self) -> State {
+        match self {
+            State::Paused => State::Paused,
+            State::Off => State::Off,
+            State::Resting { since } => State::Resting { since: *since },
+            other => panic!("stay() called on {:?}", other),
+        }
+    }
+}