dirge-code
diff --git a/‎src/agent/recovery.rs‎
Lines changed: 30 additions & 0 deletions b/‎src/agent/recovery.rs‎
Lines changed: 30 additions & 0 deletions
diff --git a/‎src/config/mod.rs‎
Lines changed: 24 additions & 12 deletions b/‎src/config/mod.rs‎
Lines changed: 24 additions & 12 deletions
diff --git a/‎src/extras/mcp/client.rs‎
Lines changed: 22 additions & 0 deletions b/‎src/extras/mcp/client.rs‎
Lines changed: 22 additions & 0 deletions
diff --git a/‎src/extras/mcp/tool.rs‎
Lines changed: 9 additions & 1 deletion b/‎src/extras/mcp/tool.rs‎
Lines changed: 9 additions & 1 deletion
diff --git a/‎src/ui/mod.rs‎
Lines changed: 51 additions & 1 deletion b/‎src/ui/mod.rs‎
Lines changed: 51 additions & 1 deletion
diff --git a/‎src/ui/slash.rs‎
Lines changed: 45 additions & 2 deletions b/‎src/ui/slash.rs‎
Lines changed: 45 additions & 2 deletions
@@ -89,6 +89,16 @@ pub fn classify_error(msg: &str) -> ErrorKind {
         return ErrorKind::RateLimit;
     }
 
+    // Anthropic's `overloaded_error` is a transient capacity signal —
+    // structurally a rate-limit response without the "rate limit" /
+    // "too many" wording. Classify as RateLimit so the retry-with-
+    // backoff policy applies; previously it fell through to `Other`
+    // and the user saw a one-shot failure on transient backend
+    // pressure.
+    if lower.contains("overloaded") {
+        return ErrorKind::RateLimit;
+    }
+
     // HTTP status codes for server errors (502/503/504 are unambiguous)
     if lower.contains(" 503 ")
         || lower.contains(" 502 ")
@@ -268,6 +278,26 @@ mod tests {
         );
     }
 
+    /// Anthropic returns `{"type": "overloaded_error", ...}` when its
+    /// service is at capacity. The body is structurally similar to a
+    /// rate-limit (transient + retryable) but doesn't contain the
+    /// "rate limit" / "too many" / "429" patterns. Without explicit
+    /// handling it falls into `Other` and dirge doesn't retry —
+    /// users see a one-shot failure on a transient backend issue.
+    #[test]
+    fn classify_anthropic_overloaded_error_as_retryable() {
+        assert_eq!(
+            classify_error("overloaded_error: Anthropic API is overloaded"),
+            ErrorKind::RateLimit,
+        );
+        // Just the lowercase token is enough — provider stringifies
+        // the structured error differently across rig versions.
+        assert_eq!(
+            classify_error("Provider overloaded; please retry later"),
+            ErrorKind::RateLimit,
+        );
+    }
+
     #[test]
     fn test_classify_auth() {
         assert_eq!(classify_error("401 unauthorized"), ErrorKind::Auth);
 
@@ -202,19 +202,31 @@ pub fn load() -> Config {
 
     #[cfg(feature = "mcp")]
     if cfg.mcp_servers.is_none() {
-        let mut headers = HashMap::new();
-        if let Some(key) = std::env::var("EXA_API_KEY").ok() {
-            headers.insert("x-api-key".to_string(), key);
+        // Only auto-register the Exa default when there's actually
+        // a non-empty API key. An empty `EXA_API_KEY=""` (e.g. unset
+        // via a `.envrc` that intentionally clears it) used to
+        // register Exa anyway with an empty header, then every web-
+        // search call failed with 401 at first use. Skip cleanly
+        // when no usable key is present.
+        match std::env::var("EXA_API_KEY") {
+            Ok(key) if !key.is_empty() => {
+                let mut headers = HashMap::new();
+                headers.insert("x-api-key".to_string(), key);
+                let mut defaults = HashMap::new();
+                defaults.insert(
+                    "Exa Web Search".to_string(),
+                    McpServerConfig::Url {
+                        url: "https://mcp.exa.ai/mcp".to_string(),
+                        headers,
+                    },
+                );
+                cfg.mcp_servers = Some(defaults);
+            }
+            _ => {
+                // Key unset or empty — leave mcp_servers as None so
+                // the host knows there's nothing to connect to.
+            }
         }
-        let mut defaults = HashMap::new();
-        defaults.insert(
-            "Exa Web Search".to_string(),
-            McpServerConfig::Url {
-                url: "https://mcp.exa.ai/mcp".to_string(),
-                headers,
-            },
-        );
-        cfg.mcp_servers = Some(defaults);
     }
 
     cfg
 
@@ -11,8 +11,30 @@ pub struct McpClientHandle {
     pub running_service: RunningService<RoleClient, ()>,
 }
 
+/// Upper bound on how long we'll wait for an MCP server to complete
+/// initialization. Command-based servers that hang on `initialize`
+/// (e.g. waiting for stdin that never comes) would otherwise pin
+/// startup indefinitely. 10s is generous for legitimate inits — npm
+/// install-on-first-run servers take a few seconds; locally-running
+/// binaries respond in <100ms. Past the cap we abort and log.
+const MCP_INIT_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
+
 impl McpClientHandle {
     pub async fn connect(server_name: String, config: &McpServerConfig) -> anyhow::Result<Self> {
+        // Wrap the entire connect in a timeout so a wedged server
+        // doesn't block startup forever. Returns a clean
+        // "init timeout" error past the cap.
+        let inner = Self::connect_inner(server_name.clone(), config);
+        match tokio::time::timeout(MCP_INIT_TIMEOUT, inner).await {
+            Ok(result) => result,
+            Err(_) => Err(anyhow::anyhow!(
+                "MCP server {server_name:?} did not initialize within {}s — skipping",
+                MCP_INIT_TIMEOUT.as_secs(),
+            )),
+        }
+    }
+
+    async fn connect_inner(server_name: String, config: &McpServerConfig) -> anyhow::Result<Self> {
         match config {
             McpServerConfig::Command { command, args, env } => {
                 let mut cmd = Command::new(command);
 
@@ -43,7 +43,15 @@ impl ToolDyn for McpTool {
             .clone()
             .unwrap_or(Cow::from(""))
             .to_string();
-        let parameters = serde_json::to_value(&self.definition.input_schema).unwrap_or_default();
+        // MCP servers that don't ship an `inputSchema` would
+        // serialize as `null`, which violates rig's expectation of
+        // an object. Substitute an empty object so the tool stays
+        // usable (the LLM just won't have a hint that args are
+        // expected, but it can still call the tool with no params).
+        let parameters = serde_json::to_value(&self.definition.input_schema)
+            .ok()
+            .filter(|v| !v.is_null())
+            .unwrap_or_else(|| serde_json::json!({}));
         Box::pin(async move {
             ToolDefinition {
                 name,
 
@@ -2340,6 +2340,24 @@ pub async fn run_interactive(
                                     KeyCode::Char('y') => break UserDecision::AllowOnce,
                                     KeyCode::Char('a') => {
                                         let pattern = suggest_pattern(&ask_req.tool, &ask_req.input);
+                                        // Refuse to store the empty-
+                                        // input placeholder as a real
+                                        // pattern. Without this, an "a"
+                                        // press on a tool call with
+                                        // empty/whitespace args would
+                                        // pin "<edit this pattern>" as
+                                        // a literal allowlist entry —
+                                        // useless and confusing.
+                                        // Fall back to AllowOnce so the
+                                        // tool still runs, but no
+                                        // permanent rule is added.
+                                        if is_placeholder_pattern(&pattern) {
+                                            renderer.write_line(
+                                                "  -> can't derive a useful pattern from empty input; allowing once only",
+                                                theme::dim(),
+                                            )?;
+                                            break UserDecision::AllowOnce;
+                                        }
                                         renderer.write_line(
                                             &format!("  -> will allow: {}", pattern),
                                             Color::Green,
@@ -2913,14 +2931,25 @@ pub async fn run_interactive(
     Ok(())
 }
 
+const ALLOW_PLACEHOLDER: &str = "<edit this pattern>";
+
+/// Whether a pattern was returned by `suggest_pattern` as the
+/// "empty input — please type a real pattern" placeholder rather
+/// than a real glob. Used by the ask-dialog to detect when the
+/// user pressed "allow always" on a degenerate input and refuse
+/// to store the placeholder as an actual allowlist entry.
+fn is_placeholder_pattern(p: &str) -> bool {
+    p == ALLOW_PLACEHOLDER
+}
+
 fn suggest_pattern(tool: &str, input: &str) -> String {
     // Refuse to suggest a catch-all wildcard for empty / whitespace-
     // only input. A user mis-clicking "(a) allow always" on an empty
     // invocation would otherwise pin an "allow everything for this
     // tool forever" rule into their session. The placeholder string
     // is intentionally not a valid glob — the UI shows it as the
     // suggested pattern, the user edits it before confirming.
-    const PLACEHOLDER: &str = "<edit this pattern>";
+    const PLACEHOLDER: &str = ALLOW_PLACEHOLDER;
     let trimmed = input.trim();
     if trimmed.is_empty() {
         return PLACEHOLDER.to_string();
@@ -3345,6 +3374,27 @@ mod tests {
         );
     }
 
+    /// `suggest_pattern` returns a literal placeholder for empty
+    /// input. The ask-dialog path that consumes it must detect the
+    /// placeholder and refuse to add it as an allowlist entry —
+    /// otherwise pressing "a" (allow always) on an empty invocation
+    /// would silently store `<edit this pattern>` as a real pattern.
+    /// The detection is exposed via `is_placeholder_pattern` so the
+    /// dialog code is unit-testable.
+    #[test]
+    fn placeholder_pattern_is_detectable() {
+        let p = suggest_pattern("bash", "");
+        assert!(
+            is_placeholder_pattern(&p),
+            "empty input should yield a detectable placeholder; got {p:?}",
+        );
+        let p = suggest_pattern("grep", "  \t  ");
+        assert!(is_placeholder_pattern(&p));
+        // A legit suggestion is NOT flagged as a placeholder.
+        let p = suggest_pattern("bash", "cargo test");
+        assert!(!is_placeholder_pattern(&p), "real pattern flagged: {p:?}");
+    }
+
     // Whitespace-only or empty input must NOT collapse to a "* *"
     // / "*" wildcard pattern that matches every subsequent call.
     // The audit flagged this as a footgun: a user accidentally
 
@@ -807,7 +807,40 @@ pub async fn handle_slash(
         "/regen-prompts" => match crate::context::prompts::regen() {
             Ok(()) => {
                 context.prompts = crate::context::prompts::load();
-                renderer.write_line("default prompts regenerated", c_agent())?;
+                // The active prompt's content may have changed on
+                // disk during regen. Re-bind `context.current_prompt`
+                // to the freshly-loaded body and rebuild the agent
+                // so the new preamble takes effect on the next turn
+                // without the user having to `/prompt <name>` again.
+                if let Some(name) = context.current_prompt_name.clone()
+                    && let Some(content) = context.prompts.get(&name)
+                {
+                    context.current_prompt = Some(content.clone());
+                }
+                let model = client.completion_model(session.model.to_string());
+                *agent = crate::provider::build_agent(
+                    model,
+                    cli,
+                    cfg,
+                    context,
+                    permission.clone(),
+                    ask_tx.clone(),
+                    None,
+                    None,
+                    bg_store.clone(),
+                    #[cfg(feature = "lsp")]
+                    None,
+                    sandbox.clone(),
+                    #[cfg(feature = "mcp")]
+                    mcp_manager,
+                    #[cfg(feature = "semantic")]
+                    semantic_manager,
+                )
+                .await;
+                renderer.write_line(
+                    "default prompts regenerated; agent rebuilt with refreshed prompt",
+                    c_agent(),
+                )?;
             }
             Err(e) => {
                 renderer.write_line(&format!("failed to regenerate prompts: {}", e), c_error())?;
@@ -986,7 +1019,13 @@ pub async fn handle_slash(
             }
         }
         "/cd" => {
-            let target = parts.get(1).copied().unwrap_or("");
+            // `splitn(3, ' ')` produces empty middle elements for
+            // consecutive spaces (`/cd   /tmp` → `["/cd", "", "/tmp"]`),
+            // which collapses to "cd home" — silent surprise.
+            // Re-derive the target from everything after the slash
+            // command using whitespace-aware splitting.
+            let raw_args = text.trim().strip_prefix("/cd").unwrap_or("").trim();
+            let target = raw_args;
             let path = if target.is_empty() {
                 dirs::home_dir().unwrap_or_default()
             } else if let Some(rest) = target.strip_prefix('~') {
@@ -1161,6 +1200,10 @@ pub async fn handle_slash(
                 "  /compress [instr]      compress with custom instructions",
                 c_result(),
             )?;
+            renderer.write_line(
+                "  /toggle <feat> [on|off] toggle a feature (e.g. /toggle todo)",
+                c_result(),
+            )?;
             #[cfg(feature = "loop")]
             {
                 let _ = renderer.write_line(