Refactor scrolling methods in ScrollState to accept an amount parameter

- Updated `scroll_up` and `scroll_down` methods to take an `amount` parameter for more flexible scrolling.
- Removed the `AgentMode` enum and related methods from the types module to simplify state management.
- Modified `AppStateRest` to remove the `mode` field and adjusted related logic.
- Enhanced `run_subagent` to build tool definitions and handle API key resolution from configuration.
- Updated command parsing to reflect changes in login handling.
- Removed onboarding overlays and related logic from input handling and rendering.
- Improved status bar to reflect connection status and agent readiness.
- Adjusted workflow panel rendering to simplify phase status display.
- Refactored edit log initialization to load from disk if available.
- Updated settings structure to use a HashMap for API keys.
- Enhanced error handling in LlmClient for authentication issues.

src/app/harness.rs

@@ -11,7 +11,6 @@ impl Harness {
     pub fn gate_tool_call(
         tool_name: &str,
         args: &serde_json::Value,
-        mode: &super::state::types::AgentMode,
         workspace_roots: &[&std::path::Path],
     ) -> Verdict {
         if let Err(e) = Self::run_catastrophic_guard(tool_name, args, workspace_roots) {
@@ -20,17 +19,11 @@ impl Harness {
         if !crate::tool::tool_is_risky(tool_name) {
             return Verdict::Allow;
         }
-        Self::classify(tool_name, mode)
+        Self::classify(tool_name)
     }
 
-    fn classify(_cmd: &str, mode: &super::state::types::AgentMode) -> Verdict {
-        if mode.auto_approve() {
-            return Verdict::Allow;
-        }
-        if matches!(mode, super::state::types::AgentMode::Plan) {
-            return Verdict::Block("mutating tools are disabled in Plan mode".to_string());
-        }
-        Verdict::Escalate
+    fn classify(_cmd: &str) -> Verdict {
+        Verdict::Allow
     }
 
     fn run_catastrophic_guard(
@@ -76,7 +69,6 @@ impl Default for Harness {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::app::state::types::AgentMode;
     use serde_json::json;
 
     fn parse_verdict(text: &str) -> Option<Verdict> {
@@ -113,58 +105,37 @@ mod tests {
     }
 
     #[test]
-    fn test_classify_auto_mode_allows() {
-        assert_eq!(Harness::classify("write", &AgentMode::Auto), Verdict::Allow);
-    }
-
-    #[test]
-    fn test_classify_yolo_mode_allows() {
-        assert_eq!(Harness::classify("write", &AgentMode::Yolo), Verdict::Allow);
-    }
-
-    #[test]
-    fn test_classify_plan_mode_blocks() {
-        let result = Harness::classify("write", &AgentMode::Plan);
-        assert!(matches!(result, Verdict::Block(_)));
-    }
-
-    #[test]
-    fn test_classify_normal_mode_escalates() {
-        assert_eq!(Harness::classify("write", &AgentMode::Normal), Verdict::Escalate);
+    fn test_classify_always_allows() {
+        assert_eq!(Harness::classify("write"), Verdict::Allow);
     }
 
     #[test]
     fn test_gate_tool_non_risky_always_allows() {
-        let mode = AgentMode::Normal;
         let roots: &[&std::path::Path] = &[];
-        let result = Harness::gate_tool_call("read", &json!({"path": "test.txt"}), &mode, roots);
+        let result = Harness::gate_tool_call("read", &json!({"path": "test.txt"}), roots);
         assert_eq!(result, Verdict::Allow);
     }
 
     #[test]
     fn test_gate_tool_bash_non_destructive_allowed_in_auto() {
-        let mode = AgentMode::Auto;
         let roots: &[&std::path::Path] = &[];
-        let result = Harness::gate_tool_call("bash", &json!({"command": "ls -la"}), &mode, roots);
+        let result = Harness::gate_tool_call("bash", &json!({"command": "ls -la"}), roots);
         assert_eq!(result, Verdict::Allow);
     }
 
     #[test]
     fn test_gate_tool_bash_destructive_blocked() {
-        let mode = AgentMode::Auto;
         let roots: &[&std::path::Path] = &[];
-        let result = Harness::gate_tool_call("bash", &json!({"command": "dd if=/dev/zero of=/dev/sda"}), &mode, roots);
+        let result = Harness::gate_tool_call("bash", &json!({"command": "dd if=/dev/zero of=/dev/sda"}), roots);
         assert!(matches!(result, Verdict::Block(_)));
     }
 
     #[test]
     fn test_gate_tool_git_operator_destructive_blocked() {
-        let mode = AgentMode::Auto;
         let roots: &[&std::path::Path] = &[];
         let result = Harness::gate_tool_call(
             "git_operator",
             &json!({"operation": "push", "args": ["--force"]}),
-            &mode,
             roots,
         );
         assert!(matches!(result, Verdict::Block(_)));