@pheem49/mint 1.16.0 → 1.17.0

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

@@ -405,45 +405,191 @@ async fn parallel_dispatch_shows_parent_calls_before_provider_finishes() {
         semantic_fact_recall: false,
         ..Default::default()
     };
-    let decisions: Vec<_> = ["dispatch-a", "dispatch-b"]
-        .into_iter()
-        .map(|id| {
-            (
-                id.into(),
-                AgentDecision {
-                    thought: String::new(),
-                    action: "dispatch_subagent".into(),
-                    input: AgentInput {
-                        name: "explorer".into(),
-                        instruction: "inspect".into(),
-                        ..Default::default()
-                    },
-                },
-            )
-        })
-        .collect();
+    let tasks = vec![
+        crate::swarm::SwarmTask {
+            role: Some("dispatch-a".into()),
+            base: Some("explorer".into()),
+            instruction: "inspect".into(),
+        },
+        crate::swarm::SwarmTask {
+            role: Some("dispatch-b".into()),
+            base: Some("explorer".into()),
+            instruction: "inspect".into(),
+        },
+    ];
     let mut events = Vec::new();
     let _ = tokio::time::timeout(
         std::time::Duration::from_millis(500),
-        run_parallel_subagent_batch(
-            &decisions,
-            1,
+        dispatch_swarm(
             &root,
             &cfg,
             "review-live-dispatch",
+            tasks,
             &mut |_| Ok(ApprovalOutcome::Approved),
             &mut |event| events.push(event),
-            &mut BTreeMap::new(),
-            &mut Vec::new(),
         ),
     )
     .await;
     for id in ["dispatch-a", "dispatch-b"] {
-        assert!(events.iter().any(|e| matches!(e, AgentProgress::ToolStart { call_id: Some(found), .. } if found == id)), "missing live {id}");
+        assert!(
+            events.iter().any(
+                |e| matches!(e, AgentProgress::SubagentStarted { subagent, .. } if subagent == id)
+            ),
+            "missing live {id}"
+        );
     }
-    assert!(
-        !events
-            .iter()
-            .any(|e| matches!(e, AgentProgress::ToolEnd { subagent: None, .. }))
-    );
+}
+
+#[test]
+fn test_agent_loop_dispatch_swarm_nested_execution() {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .thread_stack_size(8 * 1024 * 1024)
+        .enable_all()
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        let config_dir = std::env::temp_dir().join(format!("mint-cfg-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(config_dir.join("mint")).unwrap();
+        unsafe {
+            std::env::set_var("XDG_CONFIG_HOME", &config_dir);
+            std::env::set_var("NO_PROXY", "127.0.0.1,localhost");
+            std::env::set_var("no_proxy", "127.0.0.1,localhost");
+        }
+
+        let workspace = std::env::temp_dir().join(format!("mint-swarm-ws-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&workspace).unwrap();
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+
+        let cfg = MintConfig {
+            ai_provider: "ollama".into(),
+            ollama_host: format!("http://127.0.0.1:{port}"),
+            ollama_model: "qwen2.5".into(),
+            semantic_fact_recall: false,
+            memory_recall: false,
+            swarm_max_parallel: 4,
+            ..Default::default()
+        };
+
+        let provider = tokio::spawn(async move {
+            // Step 1: Parent agent requests completion. We return tool_calls: dispatch_agents with 3 tasks.
+            // Steps 2, 3, 4: Each of the 3 subagents requests completion. We return finish.
+            // Step 5: Parent agent finishes with summary.
+            for step in 0..10 {
+                let Ok((mut socket, _)) = listener.accept().await else {
+                    break;
+                };
+                let mut bytes = Vec::new();
+                let mut chunk = [0; 4096];
+                let (end, length) = loop {
+                    let n = socket.read(&mut chunk).await.unwrap();
+                    if n == 0 {
+                        return;
+                    }
+                    bytes.extend_from_slice(&chunk[..n]);
+                    if let Some(end) = bytes.windows(4).position(|w| w == b"\r\n\r\n") {
+                        let header = String::from_utf8_lossy(&bytes[..end]);
+                        let length = header
+                            .lines()
+                            .find_map(|l| {
+                                l.to_ascii_lowercase()
+                                    .strip_prefix("content-length:")
+                                    .and_then(|v| v.trim().parse::<usize>().ok())
+                            })
+                            .unwrap_or(0);
+                        break (end + 4, length);
+                    }
+                };
+                while bytes.len() < end + length {
+                    let n = socket.read(&mut chunk).await.unwrap();
+                    if n == 0 {
+                        return;
+                    }
+                    bytes.extend_from_slice(&chunk[..n]);
+                }
+
+                let req_body_str = String::from_utf8_lossy(&bytes[end..end + length]);
+                let is_subagent = req_body_str.contains("Task from parent agent");
+
+                let (action, args) = if is_subagent {
+                    (
+                        "finish",
+                        json!({"summary": "Subagent findings: all good", "verification": "verified"}),
+                    )
+                } else if step == 0 {
+                    (
+                        "dispatch_agents",
+                        json!({
+                            "tasks": [
+                                {"role": "recon", "instruction": "survey files in swarm"},
+                                {"role": "tui-tracer", "instruction": "trace tui swarm"},
+                                {"role": "gui-tracer", "instruction": "trace gui strip"}
+                            ]
+                        }),
+                    )
+                } else {
+                    (
+                        "finish",
+                        json!({"summary": "All 3 subagents finished successfully", "verification": "done"}),
+                    )
+                };
+
+                let body = format!(
+                    "{}\n",
+                    json!({
+                        "model": "qwen2.5",
+                        "message": {
+                            "role": "assistant",
+                            "content": "",
+                            "tool_calls": [{"function": {"name": action, "arguments": args}}]
+                        },
+                        "done": true
+                    })
+                );
+                let _ = socket.write_all(format!(
+                    "HTTP/1.1 200 OK\r\nContent-Type: application/x-ndjson\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                    body.len()
+                ).as_bytes()).await;
+            }
+        });
+
+        let chat = format!("parent-agent-turn-{}", uuid::Uuid::new_v4());
+        let agent_task = tokio::spawn(async move {
+            orchestrate_agent_loop(
+                &cfg,
+                "dispatch 3 subagents",
+                &workspace,
+                None,
+                None,
+                None,
+                Some(&chat),
+                None,
+                None,
+                None,
+                true,
+                false,
+                |_| Ok(ApprovalOutcome::Approved),
+                |_| {},
+                |_| {},
+            )
+            .await
+        });
+
+        let res = tokio::time::timeout(std::time::Duration::from_secs(10), agent_task).await;
+        let agent_res = res.unwrap().unwrap().unwrap();
+        assert!(agent_res.summary.contains("All 3 subagents finished successfully") || agent_res.summary.contains("Subagent"));
+        provider.abort();
+    });
+}
+
+#[test]
+fn plan_mode_allows_dispatch_agents_and_subagent() {
+    assert!(plan_mode_allows("dispatch_agents", &AgentInput::default()));
+    assert!(plan_mode_allows(
+        "dispatch_subagent",
+        &AgentInput::default()
+    ));
 }

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

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

@@ -61,11 +61,21 @@ 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()))?;
+                    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 +84,9 @@ 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 => {
+                    run_shell(root, config, chat_id, command, &input.retry_reason).await
+                }
                 ApprovalOutcome::Denied => Ok(format!("User denied shell command: {}", command)),
                 ApprovalOutcome::Intercepted(obs) => Ok(obs),
             }
@@ -89,6 +101,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 +127,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 +162,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 +195,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 +224,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]"

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",