@pheem49/mint 1.16.0 → 1.18.0

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

@@ -41,7 +41,7 @@ pub(in crate::orchestration) async fn execute(
             let path = if let Some(skill) = known_skill {
                 PathBuf::from(skill.source_path)
             } else {
-                workspace_path(root, required(&input.path, "path")?)?
+                agent_read_path(root, required(&input.path, "path")?, config)?
             };
             let start = input.start_line.unwrap_or(1);
             let end = input.end_line.unwrap_or_else(|| start.saturating_add(239));
@@ -96,8 +96,36 @@ pub(in crate::orchestration) async fn execute(
                     "apply_patch requires at least one hunk".into(),
                 ));
             }
-            let edit = build_code_patch(root, patch.path.clone(), &patch.hunks, config)
-                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            let edit = match build_code_patch(root, patch.path.clone(), &patch.hunks, config) {
+                Ok(edit) => edit,
+                Err(e) => {
+                    let target_full_path = root.join(&patch.path);
+                    if let Ok(file_content) = std::fs::read_to_string(&target_full_path) {
+                        for (idx, hunk) in patch.hunks.iter().enumerate() {
+                            let occurrences = file_content.matches(hunk.old_text.as_str()).count();
+                            if occurrences == 0 {
+                                let guidance = crate::orchestration::diagnostics::format_patch_not_found_guidance(
+                                    &file_content,
+                                    &hunk.old_text,
+                                    idx + 1,
+                                    &patch.path,
+                                );
+                                return Err(OrchestrationError::Agent(guidance));
+                            } else if occurrences > 1 && !hunk.replace_all {
+                                let guidance = crate::orchestration::diagnostics::format_ambiguous_patch_guidance(
+                                    &file_content,
+                                    &hunk.old_text,
+                                    idx + 1,
+                                    &patch.path,
+                                    occurrences,
+                                );
+                                return Err(OrchestrationError::Agent(guidance));
+                            }
+                        }
+                    }
+                    return Err(OrchestrationError::Agent(e.to_string()));
+                }
+            };
             let proposal = propose_code_edits(root, std::slice::from_ref(&edit), config)
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
             let diff = proposal
@@ -190,6 +218,7 @@ pub(in crate::orchestration) async fn execute(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::CodePatchHunk;
 
     #[tokio::test]
     async fn skill_writes_require_separate_approval_even_when_file_edits_are_allowed() {

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

@@ -1,5 +1,4 @@
 pub(super) mod avatar;
-pub(super) mod browser;
 pub(super) mod code_search;
 pub(super) mod files;
 pub(super) mod git;
@@ -12,3 +11,8 @@ pub(super) mod shell;
 pub(super) mod web;
 
 pub(super) mod mods;
+
+pub(super) mod dispatch;
+pub use dispatch::execute_mod_requests;
+pub(crate) use dispatch::execute_tool_from_json;
+pub(super) use dispatch::*;

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

@@ -14,6 +14,79 @@ fn persist_plan_to_workspace(root: &Path, plan: &ActivePlan) {
     }
 }
 
+fn load_plan_from_workspace(root: &Path) -> Option<ActivePlan> {
+    let plan_file = root.join(".agents").join("plans").join("active_plan.json");
+    let content = std::fs::read_to_string(plan_file).ok()?;
+    serde_json::from_str(&content).ok()
+}
+
+fn parse_plan_step_update(raw: &str) -> (&'static str, String) {
+    let trimmed = raw.trim();
+    let lower = trimmed.to_ascii_lowercase();
+
+    const PREFIXES: &[(&str, &str)] = &[
+        ("[x]", "completed"),
+        ("[✓]", "completed"),
+        ("done:", "completed"),
+        ("completed:", "completed"),
+        ("[>]", "in_progress"),
+        ("in_progress:", "in_progress"),
+        ("in-progress:", "in_progress"),
+        ("current:", "in_progress"),
+        ("[!]", "failed"),
+        ("[✗]", "failed"),
+        ("failed:", "failed"),
+        ("blocked:", "failed"),
+        ("[ ]", "pending"),
+        ("[]", "pending"),
+        ("pending:", "pending"),
+        ("todo:", "pending"),
+    ];
+
+    for &(prefix, status) in PREFIXES {
+        if lower.starts_with(prefix) {
+            let rest = trimmed[prefix.len()..]
+                .trim_start_matches(|c: char| c == '-' || c == ':' || c.is_whitespace())
+                .trim();
+            return (
+                status,
+                if rest.is_empty() {
+                    trimmed.to_string()
+                } else {
+                    rest.to_string()
+                },
+            );
+        }
+    }
+
+    // Check trailing parenthesized status markers like "Step 1 (completed)"
+    const SUFFIXES: &[(&str, &str)] = &[
+        ("(completed)", "completed"),
+        ("(done)", "completed"),
+        ("(in_progress)", "in_progress"),
+        ("(in-progress)", "in_progress"),
+        ("(current)", "in_progress"),
+        ("(failed)", "failed"),
+        ("(blocked)", "failed"),
+        ("(pending)", "pending"),
+    ];
+    for &(suffix, status) in SUFFIXES {
+        if lower.ends_with(suffix) {
+            let rest = trimmed[..trimmed.len() - suffix.len()].trim();
+            return (
+                status,
+                if rest.is_empty() {
+                    trimmed.to_string()
+                } else {
+                    rest.to_string()
+                },
+            );
+        }
+    }
+
+    ("pending", trimmed.to_string())
+}
+
 pub(in crate::orchestration) async fn execute(
     action: &str,
     input: &AgentInput,
@@ -71,47 +144,22 @@ pub(in crate::orchestration) async fn execute(
                 .iter()
                 .enumerate()
                 .map(|(idx, step)| {
-                    let lower = step.to_ascii_lowercase();
-                    let status = if lower.starts_with("[x]")
-                        || lower.starts_with("[✓]")
-                        || lower.contains("completed")
-                        || lower.contains("done")
-                    {
-                        "completed".to_string()
-                    } else if lower.starts_with("[>]")
-                        || lower.contains("in_progress")
-                        || lower.contains("current")
-                    {
-                        "in_progress".to_string()
-                    } else {
-                        "pending".to_string()
-                    };
-                    let title = step
-                        .trim_start_matches(|c| {
-                            c == '['
-                                || c == ']'
-                                || c == 'x'
-                                || c == 'X'
-                                || c == '✓'
-                                || c == ' '
-                                || c == '>'
-                        })
-                        .trim()
-                        .to_string();
+                    let (status, title) = parse_plan_step_update(step);
                     PlanTaskItem {
                         id: format!("step-{}", idx + 1),
-                        title: if title.is_empty() {
-                            step.clone()
-                        } else {
-                            title
-                        },
-                        status,
+                        title,
+                        status: status.to_string(),
                     }
                 })
                 .collect();
 
             let objective = if !input.summary.trim().is_empty() {
                 input.summary.trim().to_string()
+            } else if let Some(existing) = load_plan_from_workspace(root)
+                .map(|p| p.objective)
+                .filter(|obj| !obj.trim().is_empty())
+            {
+                existing
             } else {
                 "Implementation Plan".to_string()
             };
@@ -125,12 +173,11 @@ pub(in crate::orchestration) async fn execute(
 
             let mut formatted = String::from("Plan Updated:\n");
             for task in &tasks {
-                let mark = if task.status == "completed" {
-                    "[✓]"
-                } else if task.status == "in_progress" {
-                    "[>]"
-                } else {
-                    "[ ]"
+                let mark = match task.status.as_str() {
+                    "completed" => "[✓]",
+                    "in_progress" => "[>]",
+                    "failed" => "[✗]",
+                    _ => "[ ]",
                 };
                 formatted.push_str(&format!("{} {} ({})\n", mark, task.title, task.status));
             }
@@ -252,10 +299,16 @@ mod tests {
         assert_eq!(plan.tasks.len(), 2);
         assert_eq!(plan.tasks[0].status, "in_progress");
 
-        // Now test update_plan
+        // Now test update_plan without summary (matching tool_catalog schema) and with
+        // colon-prefixed statuses ("done: ...", "in_progress: ...", "pending: ...")
         let update_input = AgentInput {
-            summary: "Test Feature".to_string(),
-            steps: vec!["[x] Step 1".to_string(), "[>] Step 2".to_string()],
+            summary: String::new(),
+            steps: vec![
+                "done: Step 1".to_string(),
+                "in_progress: Inspect current state".to_string(),
+                "[ ] Ensure streaming is done".to_string(),
+                "failed: Broken step".to_string(),
+            ],
             ..AgentInput::default()
         };
         let update_res = execute(
@@ -273,8 +326,15 @@ mod tests {
         assert!(update_res.contains("[✓] Step 1"));
         let updated_content = std::fs::read_to_string(&plan_file).unwrap();
         let updated_plan: ActivePlan = serde_json::from_str(&updated_content).unwrap();
+        assert_eq!(updated_plan.objective, "Test Feature");
         assert_eq!(updated_plan.tasks[0].status, "completed");
+        assert_eq!(updated_plan.tasks[0].title, "Step 1");
         assert_eq!(updated_plan.tasks[1].status, "in_progress");
+        assert_eq!(updated_plan.tasks[1].title, "Inspect current state");
+        assert_eq!(updated_plan.tasks[2].status, "pending");
+        assert_eq!(updated_plan.tasks[2].title, "Ensure streaming is done");
+        assert_eq!(updated_plan.tasks[3].status, "failed");
+        assert_eq!(updated_plan.tasks[3].title, "Broken step");
 
         let _ = std::fs::remove_dir_all(&temp);
     }

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

@@ -324,10 +324,25 @@ pub(in crate::orchestration) async fn execute(
                 ApprovalOutcome::Intercepted(obs) => Ok(obs),
             }
         }
-        "dispatch_subagent" => {
-            let name = required(&input.name, "name")?;
-            let task = required(&input.instruction, "instruction")?;
-            dispatch_one_subagent(root, config, chat_id, name, task, approve_cb, progress).await
+        "dispatch_agents" | "dispatch_subagent" => {
+            let tasks: Vec<crate::swarm::SwarmTask> = if !input.tasks.is_empty() {
+                input.tasks.iter().cloned().map(Into::into).collect()
+            } else if !input.instruction.trim().is_empty() {
+                vec![crate::swarm::SwarmTask {
+                    role: None,
+                    base: if input.name.trim().is_empty() {
+                        None
+                    } else {
+                        Some(input.name.clone())
+                    },
+                    instruction: input.instruction.clone(),
+                }]
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "dispatch_agents requires at least one task with an 'instruction'".into(),
+                ));
+            };
+            dispatch_swarm(root, config, chat_id, tasks, approve_cb, progress).await
         }
         "mcp_tool" | "mcp_list_tools" => execute_mcp_outcome(
             action,

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

@@ -29,7 +29,7 @@ pub(in crate::orchestration) async fn execute(
             read_diagnostics(&path, config, chat_id).await
         }
         "view_image" => {
-            let path = workspace_path(root, required(&input.path, "path")?)?;
+            let path = agent_read_path(root, required(&input.path, "path")?, config)?;
             view_image(&path, config)
         }
         "search_docs" => {

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

@@ -2,38 +2,62 @@ use std::path::Path;
 
 use super::super::*;
 
-/// Catch ordinary URL launcher commands, not arbitrary shell programs. This is
-/// a workflow guard, not a shell security boundary.
-fn launches_external_url(command: &str) -> bool {
-    let Some(tokens) = shlex::split(command) else {
-        return false;
-    };
-    let Some(program) = tokens.first() else {
-        return false;
-    };
-    let program = program.rsplit(['/', '\\']).next().unwrap_or(program);
-    let launcher = match program.to_ascii_lowercase().as_str() {
-        "xdg-open" | "open" | "wslview" | "sensible-browser" | "start-process" | "start" => true,
-        "gio" => tokens.get(1).is_some_and(|arg| arg == "open"),
-        _ => false,
-    };
-    launcher
-        && tokens.iter().skip(1).any(|arg| {
-            reqwest::Url::parse(arg).is_ok_and(|url| {
-                matches!(url.scheme(), "http" | "https") && url.host_str().is_some()
-            })
-        })
+/// Deletes a Chrome run's throw-away profile once the tool call is over, however
+/// it ends (success, denial, repeat refusal, error). Background jobs outlive the
+/// call, so they disarm it and rely on the stale-profile sweep instead.
+struct ProfileCleanup<'a>(Option<&'a crate::browser::headless::ChromeRun>);
+
+impl ProfileCleanup<'_> {
+    fn disarm(&mut self) {
+        self.0 = None;
+    }
+}
+
+impl Drop for ProfileCleanup<'_> {
+    fn drop(&mut self) {
+        if let Some(run) = self.0 {
+            run.discard_profile();
+        }
+    }
 }
 
-pub(in crate::orchestration) async fn prevent_duplicate_browser_launch(
-    command: &str,
-) -> Result<(), OrchestrationError> {
-    if launches_external_url(command) && crate::browser::session_finish_evidence().await {
-        return Err(OrchestrationError::Agent(
-            "External URL launch skipped: this task already uses the automation browser. Use browser_observe/browser_read to inspect its current page, browser_screenshot for visual inspection, or browser_open if navigation is still needed. Do not open the same URL in another browser.".into(),
-        ));
+/// Refuses to capture the same page with the same options twice in one turn:
+/// that is the screenshot → view_image → recapture loop. A `retryReason` is the
+/// model's explicit statement that the page changed, and a deleted capture file
+/// may always be retaken.
+fn repeat_capture_notice(
+    run: &crate::browser::headless::ChromeRun,
+    root: &Path,
+    retry_reason: &str,
+) -> Option<String> {
+    if !retry_reason.trim().is_empty() {
+        return None;
+    }
+    let previous = reliability::recorded_capture(run.key.as_ref()?.as_str())?;
+    match previous {
+        Some(file) if root.join(&file).exists() => Some(format!(
+            "Already captured: this page was captured with the same options earlier in this turn at {file}. \
+             Call view_image on that file once (or read it) instead of capturing again, or pass \
+             retryReason if the page must be fetched again."
+        )),
+        Some(_) => None,
+        None => Some(
+            "Already read: this page was read with the same options earlier in this turn. Reuse that \
+             output, change the options (for example capture a screenshot), or pass retryReason if the \
+             page must be fetched again."
+                .into(),
+        ),
+    }
+}
+
+/// Remembers a successful capture so `repeat_capture_notice` can spot repeats.
+fn record_capture_result(run: &crate::browser::headless::ChromeRun, result: &str) {
+    if let Some(key) = &run.key
+        && !result.starts_with("Skipped")
+        && !shell_result_failed(result)
+    {
+        reliability::record_capture(key.as_str(), run.output.clone());
     }
-    Ok(())
 }
 
 /// Handles the subset of `execute_tool` actions related to shell.
@@ -50,7 +74,16 @@ pub(in crate::orchestration) async fn execute(
     match action {
         "run_shell" => {
             let command = required(&input.command, "command")?;
-            prevent_duplicate_browser_launch(command).await?;
+            // Headless Chrome is made reliable (flags, throw-away profile, timeout) and
+            // de-duplicated here, so the model only has to write the plain command.
+            let chrome = crate::browser::headless::prepare(command, config);
+            let mut cleanup = ProfileCleanup(chrome.as_ref());
+            let command = chrome.as_ref().map_or(command, |run| run.command.as_str());
+            if let Some(run) = &chrome
+                && let Some(notice) = repeat_capture_notice(run, root, &input.retry_reason)
+            {
+                return Ok(notice);
+            }
             let mode = classify_shell_command(command).mode.as_str().to_owned();
             let approved = approve_cb(&AgentApproval::RunShell {
                 command: command.to_owned(),
@@ -61,11 +94,22 @@ pub(in crate::orchestration) async fn execute(
 
             match approved {
                 ApprovalOutcome::Approved if input.background => {
+                    if let Err(reason) = reliability::before_shell(command, &input.retry_reason) {
+                        return Ok(format!("Skipped: {reason}"));
+                    }
                     let started = crate::bg_shell::with_context(
                         crate::bg_shell::chat_context(root, chat_id),
                         || crate::bg_shell::start_background(root, config, command),
                     )
                     .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+                    cleanup.disarm();
+                    reliability::record(
+                        command,
+                        reliability::ExecutionState::Running,
+                        None,
+                        Some(started.id.clone()),
+                        "",
+                    );
                     Ok(format!(
                         "job_id: {}\npid: {}\nstatus: running\nUse the 'shell_output' tool with this job_id to check on it, and 'kill_shell' to stop it.",
                         started.id,
@@ -74,7 +118,14 @@ pub(in crate::orchestration) async fn execute(
                             .map_or_else(|| "unknown".to_string(), |p| p.to_string()),
                     ))
                 }
-                ApprovalOutcome::Approved => run_shell(root, config, chat_id, command).await,
+                ApprovalOutcome::Approved => {
+                    let out =
+                        run_shell(root, config, chat_id, command, &input.retry_reason).await?;
+                    if let Some(run) = &chrome {
+                        record_capture_result(run, &out);
+                    }
+                    Ok(out)
+                }
                 ApprovalOutcome::Denied => Ok(format!("User denied shell command: {}", command)),
                 ApprovalOutcome::Intercepted(obs) => Ok(obs),
             }
@@ -89,6 +140,9 @@ pub(in crate::orchestration) async fn execute(
                     "No accessible background job with that id".into(),
                 ));
             }
+            let snapshot = crate::bg_shell::snapshot(job_id)
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            reliability::record_job(&snapshot);
             crate::bg_shell::poll_output(job_id)
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))
         }
@@ -112,7 +166,7 @@ pub(in crate::orchestration) async fn execute(
             }
             let mut output = Vec::new();
             for command in &input.commands {
-                output.push(run_shell(root, config, chat_id, command).await?);
+                output.push(run_shell(root, config, chat_id, command, &input.retry_reason).await?);
             }
             Ok(output.join("\n\n"))
         }
@@ -147,7 +201,10 @@ pub(in crate::orchestration) async fn execute(
                 ));
             };
 
-            let out = run_shell(root, config, chat_id, &cmd).await?;
+            let out = run_shell(root, config, chat_id, &cmd, &input.retry_reason).await?;
+            if out.starts_with("Skipped") {
+                return Ok(out);
+            }
             let failed = shell_result_failed(&out);
             let status_mark = if failed {
                 "✗ [TEST FAILED]"
@@ -177,7 +234,10 @@ pub(in crate::orchestration) async fn execute(
                 ));
             };
 
-            let out = run_shell(root, config, chat_id, &cmd).await?;
+            let out = run_shell(root, config, chat_id, &cmd, &input.retry_reason).await?;
+            if out.starts_with("Skipped") {
+                return Ok(out);
+            }
             let failed = shell_result_failed(&out);
             let status_mark = if failed {
                 "✗ [TYPECHECK FAILED]"
@@ -203,7 +263,10 @@ pub(in crate::orchestration) async fn execute(
                 ));
             };
 
-            let out = run_shell(root, config, chat_id, &cmd).await?;
+            let out = run_shell(root, config, chat_id, &cmd, &input.retry_reason).await?;
+            if out.starts_with("Skipped") {
+                return Ok(out);
+            }
             let failed = shell_result_failed(&out);
             let status_mark = if failed {
                 "✗ [LINT FAILED]"
@@ -221,38 +284,70 @@ pub(in crate::orchestration) async fn execute(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::browser::headless::{HostEnv, prepare_with};
 
-    #[test]
-    fn external_url_launch_detection_preserves_other_shell_work() {
-        for command in [
-            "xdg-open 'https://example.com/watch?v=1&list=2'",
-            "/usr/bin/xdg-open https://example.com &",
-            "open -a Firefox https://example.com",
-            "gio open https://example.com",
-            "wslview https://example.com",
-            "Start-Process https://example.com",
-        ] {
-            assert!(launches_external_url(command), "{command}");
-        }
-        for command in [
-            "xdg-open /tmp/report.pdf",
-            "open /tmp",
-            "curl https://example.com",
-            "echo xdg-open https://example.com",
-            "gio info https://example.com",
-            "cargo test",
-        ] {
-            assert!(!launches_external_url(command), "{command}");
-        }
+    fn chrome(command: &str) -> crate::browser::headless::ChromeRun {
+        let host = HostEnv {
+            no_sandbox: false,
+            linux_timeout: false,
+            profile_root: std::env::temp_dir().join("mint-headless-shell-test"),
+        };
+        prepare_with(command, &MintConfig::default(), &host).unwrap()
+    }
+
+    #[tokio::test]
+    async fn a_repeated_capture_of_the_same_page_is_refused_until_a_reason_is_given() {
+        let dir = std::env::temp_dir().join(format!("mint-capture-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        reliability::scope(async {
+            let first = chrome("google-chrome --screenshot=a.png https://example.com/shop");
+            assert!(
+                repeat_capture_notice(&first, &dir, "").is_none(),
+                "first capture runs"
+            );
+            std::fs::write(dir.join("a.png"), b"png").unwrap();
+            record_capture_result(&first, "");
+
+            let again = chrome("google-chrome --screenshot=b.png https://example.com/shop/");
+            let notice = repeat_capture_notice(&again, &dir, "").expect("repeat refused");
+            assert!(
+                notice.contains("a.png") && notice.contains("view_image"),
+                "{notice}"
+            );
+            assert!(
+                repeat_capture_notice(&again, &dir, "page changed after login").is_none(),
+                "a retryReason allows a deliberate recapture"
+            );
+            std::fs::remove_file(dir.join("a.png")).unwrap();
+            assert!(
+                repeat_capture_notice(&again, &dir, "").is_none(),
+                "a deleted capture may be retaken"
+            );
+        })
+        .await;
+        let _ = std::fs::remove_dir_all(&dir);
     }
 
     #[tokio::test]
-    async fn external_url_launch_allowed_without_browser_use() {
-        crate::browser::run_session(async {
-            prevent_duplicate_browser_launch("xdg-open https://example.com")
-                .await
-                .unwrap();
+    async fn dom_reads_repeat_detection_and_failed_runs_are_not_recorded() {
+        let dir = std::env::temp_dir();
+        reliability::scope(async {
+            let dom = chrome("google-chrome --dump-dom https://example.com");
+            record_capture_result(&dom, "Error: Chrome failed\nexit: 1\n");
+            assert!(
+                repeat_capture_notice(&dom, &dir, "").is_none(),
+                "failures can be retried"
+            );
+            record_capture_result(&dom, "<html></html>");
+            let notice = repeat_capture_notice(&dom, &dir, "").expect("repeat refused");
+            assert!(notice.starts_with("Already read"), "{notice}");
         })
         .await;
     }
+
+    #[test]
+    fn commands_without_a_single_url_are_never_deduplicated() {
+        let run = chrome("google-chrome --dump-dom");
+        assert!(repeat_capture_notice(&run, &std::env::temp_dir(), "").is_none());
+    }
 }

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

@@ -46,7 +46,11 @@ pub(in crate::orchestration) async fn execute(
                                 let image_line = h
                                     .image_url
                                     .as_deref()
-                                    .map(|img| format!("   Image: {img}\n"))
+                                    .map(|img| {
+                                        let normalized =
+                                            crate::web_search::normalize_web_search_image_url(img);
+                                        format!("   Image: {normalized}\n")
+                                    })
                                     .unwrap_or_default();
                                 format!(
                                     "{}. {}\n   URL: {}\n{}{}\n",