@pheem49/mint 1.8.1 → 1.9.0

package/crates/mint-core/src/orchestration.rs

@@ -71,15 +71,14 @@ pub async fn resolve_github_links(message: &str, config: &MintConfig) -> String
                 .collect();
 
             let repo_key = format!("{owner}/{repo_clean}");
-            if resolved_repos.insert(repo_key.clone()) {
-                if let Ok(summary) =
+            if resolved_repos.insert(repo_key.clone())
+                && let Ok(summary) =
                     crate::code_tools::fetch_github_repo_summary(owner, &repo_clean).await
-                {
-                    resolved_msg.push_str(&format!(
+            {
+                resolved_msg.push_str(&format!(
                         "\n\n--- Auto-Resolved GitHub Metadata for {} ---\n{}\n--------------------------------------------",
                         repo_key, summary
                     ));
-                }
             }
         }
     }
@@ -93,7 +92,7 @@ pub async fn orchestrate_chat(
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let response = send_chat(config, &enriched).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -122,7 +121,7 @@ where
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let response = stream_chat(config, &enriched, on_chunk).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -147,7 +146,7 @@ pub async fn orchestrate_chat_with_fallback(
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let (response, fallback) = send_chat_with_fallback(config, &enriched).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -176,7 +175,7 @@ where
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let (response, fallback) = stream_chat_with_fallback(config, &enriched, on_chunk).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -194,7 +193,11 @@ where
     Ok((response, fallback))
 }
 
-fn enrich_request(memory: &MemoryStore, request: &ChatRequest) -> Result<ChatRequest, MemoryError> {
+fn enrich_request(
+    config: &MintConfig,
+    memory: &MemoryStore,
+    request: &ChatRequest,
+) -> Result<ChatRequest, MemoryError> {
     let mut interactions =
         memory.recent_interactions_for_chat(request_chat_id(request), CONTEXT_LIMIT)?;
     interactions.reverse();
@@ -206,18 +209,18 @@ fn enrich_request(memory: &MemoryStore, request: &ChatRequest) -> Result<ChatReq
     let mut enriched = request.clone();
 
     let mut profile_instructions = String::new();
-    if let Ok(Some(name)) = memory.get_profile("name") {
-        if !name.trim().is_empty() {
-            profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
-        }
+    if let Ok(Some(name)) = memory.get_profile("name")
+        && !name.trim().is_empty()
+    {
+        profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
     }
-    if let Ok(Some(preferences)) = memory.get_profile("preferences") {
-        if !preferences.trim().is_empty() {
-            profile_instructions.push_str(&format!(
-                "User Preferences & Profile:\n{}\n",
-                preferences.trim()
-            ));
-        }
+    if let Ok(Some(preferences)) = memory.get_profile("preferences")
+        && !preferences.trim().is_empty()
+    {
+        profile_instructions.push_str(&format!(
+            "User Preferences & Profile:\n{}\n",
+            preferences.trim()
+        ));
     }
 
     if !profile_instructions.is_empty() {
@@ -230,6 +233,16 @@ fn enrich_request(memory: &MemoryStore, request: &ChatRequest) -> Result<ChatReq
         .to_owned();
     }
 
+    // Inject active AI model/provider context to system instructions
+    let active_model_info = format!(
+        "\n\n[Active Environment Context]\n\
+         You are running on: {}\n\
+         Using AI Model: {}\n",
+        config.ai_provider,
+        config.active_model()
+    );
+    enriched.system_instruction.push_str(&active_model_info);
+
     if !transcript.is_empty() {
         enriched.system_instruction = format!(
             "{}\n\nRecent conversation context:\n{}",
@@ -549,6 +562,10 @@ pub enum ApprovalOutcome {
 pub enum AgentProgress {
     Thinking {
         elapsed_secs: u64,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        agent_name: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        model_name: Option<String>,
     },
     Thought {
         thought: String,
@@ -658,12 +675,105 @@ where
     Ok(Option::<AgentInput>::deserialize(deserializer)?.unwrap_or_default())
 }
 
+fn resolve_agent_config(
+    config: &MintConfig,
+    agent_id: Option<&str>,
+    trajectory: &[String],
+) -> (MintConfig, String, Option<String>, Option<String>) {
+    if !config.enable_agent_collaboration {
+        return (config.clone(), "".to_string(), None, None);
+    }
+
+    let enabled_agents: Vec<&crate::config::AgentConfig> =
+        config.agents.iter().filter(|a| a.enabled).collect();
+    if enabled_agents.is_empty() {
+        return (config.clone(), "".to_string(), None, None);
+    }
+
+    let active_agent = if let Some(id) = agent_id {
+        enabled_agents.iter().find(|a| a.id == id).copied()
+    } else {
+        // Multi-Agent Pipeline Collaboration (Planner -> Coder -> Reviewer)
+        let plan_created = trajectory
+            .iter()
+            .any(|step| step.contains("- Action: create_plan"));
+        if !plan_created {
+            if let Some(planner) = enabled_agents.iter().find(|a| a.id == "planner") {
+                Some(*planner)
+            } else {
+                enabled_agents.iter().find(|a| a.id == "coder").copied()
+            }
+        } else {
+            // Check if edits have been made to verify
+            let edits_made = trajectory.iter().any(|step| {
+                step.contains("- Action: write_file") || step.contains("- Action: apply_patch")
+            });
+            if edits_made {
+                if let Some(last_step) = trajectory.last() {
+                    if last_step.contains("- Action: write_file")
+                        || last_step.contains("- Action: apply_patch")
+                    {
+                        if let Some(reviewer) = enabled_agents.iter().find(|a| a.id == "reviewer") {
+                            Some(*reviewer)
+                        } else {
+                            enabled_agents.iter().find(|a| a.id == "coder").copied()
+                        }
+                    } else {
+                        enabled_agents.iter().find(|a| a.id == "coder").copied()
+                    }
+                } else {
+                    enabled_agents.iter().find(|a| a.id == "coder").copied()
+                }
+            } else {
+                enabled_agents.iter().find(|a| a.id == "coder").copied()
+            }
+        }
+    };
+
+    let Some(agent) = active_agent else {
+        return (config.clone(), "".to_string(), None, None);
+    };
+
+    let mut cfg_clone = config.clone();
+    cfg_clone.ai_provider = agent.provider.clone();
+    cfg_clone.gemini_model = agent.model.clone();
+    cfg_clone.openai_model = agent.model.clone();
+    cfg_clone.anthropic_model = agent.model.clone();
+    cfg_clone.openrouter_model = agent.model.clone();
+    cfg_clone.deepseek_model = agent.model.clone();
+    cfg_clone.hf_model = agent.model.clone();
+    cfg_clone.local_model_name = agent.model.clone();
+    cfg_clone.ollama_model = agent.model.clone();
+
+    if let Some(key) = &agent.api_key
+        && !key.trim().is_empty()
+    {
+        match agent.provider.as_str() {
+            "gemini" => cfg_clone.api_key = key.clone(),
+            "openai" => cfg_clone.openai_api_key = key.clone(),
+            "anthropic" => cfg_clone.anthropic_api_key = key.clone(),
+            "openrouter" => cfg_clone.openrouter_api_key = key.clone(),
+            "deepseek" => cfg_clone.deepseek_api_key = key.clone(),
+            "huggingface" => cfg_clone.hf_api_key = key.clone(),
+            _ => {}
+        }
+    }
+
+    (
+        cfg_clone,
+        agent.system_instruction.clone(),
+        Some(agent.name.clone()),
+        Some(agent.model.clone()),
+    )
+}
+
 pub async fn orchestrate_agent_loop<Approve, Progress, Chunk>(
     config: &MintConfig,
     task: &str,
     root: &Path,
     image_data_uri: Option<String>,
     chat_id: Option<&str>,
+    agent_id: Option<&str>,
     fast_mode: bool,
     mut approve: Approve,
     mut progress: Progress,
@@ -695,18 +805,18 @@ where
 
     if let Ok(memory) = MemoryStore::open_default() {
         let mut profile_instructions = String::new();
-        if let Ok(Some(name)) = memory.get_profile("name") {
-            if !name.trim().is_empty() {
-                profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
-            }
+        if let Ok(Some(name)) = memory.get_profile("name")
+            && !name.trim().is_empty()
+        {
+            profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
         }
-        if let Ok(Some(preferences)) = memory.get_profile("preferences") {
-            if !preferences.trim().is_empty() {
-                profile_instructions.push_str(&format!(
-                    "User Preferences & Profile:\n{}\n",
-                    preferences.trim()
-                ));
-            }
+        if let Ok(Some(preferences)) = memory.get_profile("preferences")
+            && !preferences.trim().is_empty()
+        {
+            profile_instructions.push_str(&format!(
+                "User Preferences & Profile:\n{}\n",
+                preferences.trim()
+            ));
         }
 
         if !profile_instructions.is_empty() {
@@ -743,20 +853,42 @@ where
     let mut trajectory: Vec<String> = Vec::new();
 
     for step in 1..=MAX_STEPS {
+        let (active_config, agent_instruction, active_agent_name, active_model_name) =
+            resolve_agent_config(config, agent_id, &trajectory);
+
         progress(AgentProgress::Thinking {
             elapsed_secs: started_at.elapsed().as_secs(),
+            agent_name: active_agent_name,
+            model_name: active_model_name.clone(),
         });
 
+        let mut active_system_prompt = system_prompt.clone();
+        if let Some(ref model_name) = active_model_name {
+            active_system_prompt.push_str(&format!(
+                "\n\n[Active Environment Context]\n\
+                 You are running on: {}\n\
+                 Using AI Model: {}\n",
+                active_config.ai_provider, model_name
+            ));
+        }
+        if !agent_instruction.is_empty() {
+            active_system_prompt.push_str(&format!(
+                "\n\nYour Current Role & System Instructions:\n{}",
+                agent_instruction
+            ));
+        }
+
         let (response, fallback) = send_chat_with_fallback(
-            config,
+            &active_config,
             &ChatRequest {
                 message: observation.clone(),
-                system_instruction: system_prompt.clone(),
+                system_instruction: active_system_prompt.clone(),
                 chat_id: Some(chat_id.to_owned()),
                 image_data_uri: pending_image.take(),
                 audio_data_uri: None,
                 document_attachment: None,
                 workspace_path: None,
+                agent_id: None,
             },
         )
         .await?;
@@ -771,7 +903,7 @@ where
             Ok(decision) => decision,
             Err(_) => {
                 let (repaired, _) = send_chat_with_fallback(
-                    config,
+                    &active_config,
                     &ChatRequest {
                         message: format!(
                             "Your previous response was not valid Mint agent JSON.\n\
@@ -779,12 +911,13 @@ where
                              Do not use markdown.\n\nPrevious response:\n{}",
                             truncate(&response.text)
                         ),
-                        system_instruction: system_prompt.clone(),
+                        system_instruction: active_system_prompt.clone(),
                         chat_id: Some(chat_id.to_owned()),
                         image_data_uri: None,
                         audio_data_uri: None,
                         document_attachment: None,
                         workspace_path: None,
+                        agent_id: None,
                     },
                 )
                 .await?;
@@ -1115,7 +1248,7 @@ where
                             .collect::<Vec<_>>()
                             .join("\n");
                         Ok(format!(
-                            "{formatted}\n\nNote: Web search succeeded using {provider} Search. In your finish summary, you MUST state that you found this information using the {provider} Search API (e.g. \"มิ้นท์ค้นหาข้อมูลนี้มาจาก {provider} Search นะคะ\")."
+                            "{formatted}\n\nNote: Web search succeeded using {provider} Search. In your finish summary, you MUST:\n1. Answer the user's question using the information above.\n2. Mention that you found this information via {provider} Search (e.g. \"I found this information using {provider} Search.\").\nDo NOT list sources manually — the UI will display them automatically."
                         ))
                     }
                 }
@@ -1140,14 +1273,14 @@ where
             if crate::is_browser_running(config).await {
                 let result = crate::browser::navigate(config, url)
                     .await
-                    .map_err(|e| OrchestrationError::Agent(e))?;
+                    .map_err(OrchestrationError::Agent)?;
                 Ok(result)
             } else {
                 let opened = if cfg!(target_os = "macos") {
                     std::process::Command::new("open").arg(url).spawn().is_ok()
                 } else if cfg!(target_os = "windows") {
                     std::process::Command::new("cmd")
-                        .args(&["/C", "start", url])
+                        .args(["/C", "start", url])
                         .spawn()
                         .is_ok()
                 } else {
@@ -1179,7 +1312,7 @@ where
             };
             let result = crate::browser::click(config, selector)
                 .await
-                .map_err(|e| OrchestrationError::Agent(e))?;
+                .map_err(OrchestrationError::Agent)?;
             Ok(result)
         }
         "browser_type" => {
@@ -1203,13 +1336,13 @@ where
             };
             let result = crate::browser::type_text(config, selector, text)
                 .await
-                .map_err(|e| OrchestrationError::Agent(e))?;
+                .map_err(OrchestrationError::Agent)?;
             Ok(result)
         }
         "browser_read" => {
             let result = crate::browser::read_page_text(config)
                 .await
-                .map_err(|e| OrchestrationError::Agent(e))?;
+                .map_err(OrchestrationError::Agent)?;
             Ok(result)
         }
         "memory_recall" => {
@@ -1365,7 +1498,7 @@ where
                 path: file_name.to_owned(),
                 content: input.file_content.clone(),
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -1388,7 +1521,7 @@ where
                 name: name.to_owned(),
                 instruction: instruction.to_owned(),
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => Ok(execute_native_plugin(config, name, instruction)
@@ -1406,7 +1539,7 @@ where
                 tool: tool.to_owned(),
                 arguments: input.arguments.clone(),
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => Ok(serde_json::to_string_pretty(
@@ -1427,7 +1560,7 @@ where
                 command: command.to_owned(),
                 mode,
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => run_shell(root, config, command),
@@ -1472,7 +1605,7 @@ where
                 hunks: patch.hunks.clone(),
                 diff,
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -1508,7 +1641,7 @@ where
                 content: input.file_content.clone(),
                 diff,
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -1702,13 +1835,13 @@ fn view_image(path: &Path, config: &MintConfig) -> Result<String, OrchestrationE
     }
     let bytes = std::fs::read(&path)
         .map_err(|e| OrchestrationError::Agent(format!("cannot read image: {e}")))?;
-    Ok(serde_json::to_string_pretty(&serde_json::json!({
+    serde_json::to_string_pretty(&serde_json::json!({
         "path": path,
         "bytes": bytes.len(),
         "mime": mime,
         "dataUri": format!("data:{mime};base64,{}", BASE64_STANDARD.encode(bytes)),
     }))
-    .map_err(|e| OrchestrationError::Agent(e.to_string()))?)
+    .map_err(|e| OrchestrationError::Agent(e.to_string()))
 }
 
 fn run_shell(
@@ -1724,14 +1857,13 @@ fn run_shell(
 
     let mut hint = "";
     let cmd_lower = command.to_lowercase();
-    if output.success {
-        if cmd_lower.contains("open")
+    if output.success
+        && (cmd_lower.contains("open")
             || cmd_lower.contains("launch")
             || cmd_lower.contains("chrome")
-            || cmd_lower.contains("firefox")
-        {
-            hint = "\nNote: Opening URLs, files, folders, or launching applications are background processes. Even if there are warnings or stdout/stderr outputs, since the command exited successfully with status 0, the operation has succeeded and you should now use the 'finish' action to inform the user.";
-        }
+            || cmd_lower.contains("firefox"))
+    {
+        hint = "\nNote: Opening URLs, files, folders, or launching applications are background processes. Even if there are warnings or stdout/stderr outputs, since the command exited successfully with status 0, the operation has succeeded and you should now use the 'finish' action to inform the user.";
     }
 
     Ok(format!(
@@ -1776,8 +1908,11 @@ fn action_fingerprint(decision: &AgentDecision) -> String {
 }
 
 fn initial_observation(task: &str, root: &Path, skills: &str) -> String {
+    let now = chrono::Local::now()
+        .format("%Y-%m-%d %H:%M:%S %Z")
+        .to_string();
     let mut observation = format!(
-        "Task: {task}\nWorkspace: {}\nLearned skills:\n{}\n",
+        "Current Time: {now}\nTask: {task}\nWorkspace: {}\nLearned skills:\n{}\n",
         root.display(),
         if skills.trim().is_empty() {
             "(none)"
@@ -2127,6 +2262,7 @@ Example response:
         audio_data_uri: None,
         document_attachment: None,
         workspace_path: None,
+        agent_id: None,
     };
 
     // Send the chat request to LLM
@@ -2148,19 +2284,19 @@ Example response:
         text_reply.to_string()
     };
 
-    if let Ok(value) = serde_json::from_str::<serde_json::Value>(&clean_json) {
-        if let Some(obj) = value.as_object() {
-            if let Some(new_name) = obj.get("name").and_then(|v| v.as_str()) {
-                let trimmed_name = new_name.trim();
-                if !trimmed_name.is_empty() && trimmed_name != current_name {
-                    memory.set_profile("name", trimmed_name)?;
-                }
+    if let Ok(value) = serde_json::from_str::<serde_json::Value>(&clean_json)
+        && let Some(obj) = value.as_object()
+    {
+        if let Some(new_name) = obj.get("name").and_then(|v| v.as_str()) {
+            let trimmed_name = new_name.trim();
+            if !trimmed_name.is_empty() && trimmed_name != current_name {
+                memory.set_profile("name", trimmed_name)?;
             }
-            if let Some(new_pref) = obj.get("preferences").and_then(|v| v.as_str()) {
-                let trimmed_pref = new_pref.trim();
-                if !trimmed_pref.is_empty() && trimmed_pref != current_pref {
-                    memory.set_profile("preferences", trimmed_pref)?;
-                }
+        }
+        if let Some(new_pref) = obj.get("preferences").and_then(|v| v.as_str()) {
+            let trimmed_pref = new_pref.trim();
+            if !trimmed_pref.is_empty() && trimmed_pref != current_pref {
+                memory.set_profile("preferences", trimmed_pref)?;
             }
         }
     }
@@ -2171,6 +2307,7 @@ Example response:
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::config::AgentConfig;
 
     #[test]
     fn preserves_request_without_history() {
@@ -2185,10 +2322,14 @@ mod tests {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         };
-        assert_eq!(
-            enrich_request(&store, &request).unwrap().system_instruction,
-            "system"
+        let config = MintConfig::default();
+        assert!(
+            enrich_request(&config, &store, &request)
+                .unwrap()
+                .system_instruction
+                .starts_with("system")
         );
     }
 
@@ -2290,4 +2431,51 @@ mod tests {
 
         assert_eq!(classification.mode.as_str(), "readOnly");
     }
+
+    #[test]
+    fn test_resolve_agent_config() {
+        let mut config = MintConfig::default();
+        config.enable_agent_collaboration = true;
+        config.agents = vec![
+            AgentConfig {
+                id: "planner".into(),
+                name: "Planner".into(),
+                provider: "openai".into(),
+                model: "gpt-4o".into(),
+                api_key: Some("test-key".into()),
+                system_instruction: "Planner instruction".into(),
+                enabled: true,
+            },
+            AgentConfig {
+                id: "coder".into(),
+                name: "Coder".into(),
+                provider: "gemini".into(),
+                model: "gemini-2.5-flash".into(),
+                api_key: None,
+                system_instruction: "Coder instruction".into(),
+                enabled: true,
+            },
+        ];
+
+        let (cfg, instr, name, model) = resolve_agent_config(&config, Some("planner"), &[]);
+        assert_eq!(cfg.ai_provider, "openai");
+        assert_eq!(cfg.openai_model, "gpt-4o");
+        assert_eq!(cfg.openai_api_key, "test-key");
+        assert_eq!(instr, "Planner instruction");
+        assert_eq!(name, Some("Planner".to_string()));
+        assert_eq!(model, Some("gpt-4o".to_string()));
+
+        let (cfg, instr, name, _model) = resolve_agent_config(&config, None, &[]);
+        assert_eq!(cfg.ai_provider, "openai");
+        assert_eq!(instr, "Planner instruction");
+        assert_eq!(name, Some("Planner".to_string()));
+
+        let trajectory =
+            vec!["Step 1:\n- Action: create_plan\n- Observation: all planned".to_string()];
+        let (cfg, instr, name, model) = resolve_agent_config(&config, None, &trajectory);
+        assert_eq!(cfg.ai_provider, "gemini");
+        assert_eq!(instr, "Coder instruction");
+        assert_eq!(name, Some("Coder".to_string()));
+        assert_eq!(model, Some("gemini-2.5-flash".to_string()));
+    }
 }

package/crates/mint-core/src/pictures.rs

@@ -79,11 +79,10 @@ pub fn list_saved_pictures() -> Result<Vec<PictureEntry>, PictureError> {
                 .thumbnail_path
                 .as_ref()
                 .is_none_or(|thumbnail_path| !thumbnail_path.exists())
+                && let Some(thumbnail_path) = create_thumbnail_from_file(&directory, &entry)
             {
-                if let Some(thumbnail_path) = create_thumbnail_from_file(&directory, &entry) {
-                    entry.thumbnail_path = Some(thumbnail_path);
-                    changed = true;
-                }
+                entry.thumbnail_path = Some(thumbnail_path);
+                changed = true;
             }
             entry.url = Some(file_url(&entry.path));
             entry.thumbnail_url = entry.thumbnail_path.as_deref().map(file_url);

package/crates/mint-core/src/semantic.rs

@@ -169,7 +169,7 @@ fn chunk_text(content: &str) -> Vec<(usize, usize, String)> {
     while start < lines.len() {
         let mut end = start;
         let mut chars = 0;
-        while end < lines.len() && (end == start || chars + lines[end].len() + 1 <= MAX_CHARS) {
+        while end < lines.len() && (end == start || chars + lines[end].len() < MAX_CHARS) {
             chars += lines[end].len() + 1;
             end += 1;
         }

package/crates/mint-core/src/shell.rs

@@ -121,7 +121,7 @@ fn run_in_sandbox(
             .arg(cwd)
             .args(["bash", "-lc", command])
             .output()?;
-        return Ok(Some(output));
+        Ok(Some(output))
     }
 
     #[cfg(target_os = "macos")]