@pheem49/mint 1.15.0 → 1.17.0

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

@@ -0,0 +1,307 @@
+//! Structured Self-Correction Diagnostics Engine
+//!
+//! Analyzes tool execution failures (such as patch text mismatches, ambiguous replacement targets,
+//! and compiler/runtime execution errors) and produces actionable self-correction guidance
+//! for the autonomous agent.
+
+use std::path::Path;
+
+/// Formats an error with actionable self-correction advice.
+pub fn format_patch_not_found_guidance(
+    file_content: &str,
+    old_text: &str,
+    hunk_index: usize,
+    path: &Path,
+) -> String {
+    let path_display = path.display();
+    let old_text_trimmed = old_text.trim();
+    let target_lines: Vec<&str> = old_text.lines().collect();
+    let file_lines: Vec<&str> = file_content.lines().collect();
+
+    // 1. Check for whitespace/newline normalized match
+    let normalized_file_content: String = file_content
+        .lines()
+        .map(|l| l.split_whitespace().collect::<Vec<_>>().join(" "))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let normalized_old_text: String = old_text
+        .lines()
+        .map(|l| l.split_whitespace().collect::<Vec<_>>().join(" "))
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    if !normalized_old_text.is_empty() && normalized_file_content.contains(&normalized_old_text) {
+        // Find approximate line number
+        let mut match_line = 1;
+        for (i, line) in file_lines.iter().enumerate() {
+            let norm_line = line.split_whitespace().collect::<Vec<_>>().join(" ");
+            let first_norm_target = target_lines
+                .first()
+                .map(|l| l.split_whitespace().collect::<Vec<_>>().join(" "))
+                .unwrap_or_default();
+            if !first_norm_target.is_empty() && norm_line.contains(&first_norm_target) {
+                match_line = i + 1;
+                break;
+            }
+        }
+        let end_line = (match_line + target_lines.len().saturating_sub(1)).max(match_line);
+
+        return format!(
+            "Error: patch hunk {hunk_index} old text was not found verbatim in {path_display}\n\n\
+            [Self-Correction Guidance]:\n\
+            • Cause: Whitespace or indentation mismatch detected around lines {match_line}–{end_line}.\n\
+            • Diagnosis: The text exists in the file, but spaces, tabs, or line endings differ from your hunk.\n\
+            • Recommended Action: Call 'read_file' with path=\"{path_display}\", start_line={match_line}, end_line={end_line} \
+            to copy the exact verbatim indentation and whitespace before applying the patch."
+        );
+    }
+
+    // 2. Sliding window similarity search across lines
+    let window_size = target_lines.len().clamp(1, 40);
+    let mut best_similarity = 0.0;
+    let mut best_line = 1;
+
+    if file_lines.len() >= window_size && !old_text_trimmed.is_empty() {
+        for i in 0..=(file_lines.len().saturating_sub(window_size)) {
+            let window_text = file_lines[i..i + window_size].join("\n");
+            let sim = jaccard_similarity(old_text_trimmed, &window_text);
+            if sim > best_similarity {
+                best_similarity = sim;
+                best_line = i + 1;
+            }
+        }
+    }
+
+    if best_similarity >= 0.5 {
+        let pct = (best_similarity * 100.0).round() as u32;
+        let end_line = best_line + window_size.saturating_sub(1);
+        let suggested_end = end_line + 5;
+        let sample_snippet = file_lines
+            [best_line.saturating_sub(1)..best_line.saturating_sub(1) + window_size.min(4)]
+            .join("\n");
+
+        format!(
+            "Error: patch hunk {hunk_index} old text was not found in {path_display}\n\n\
+            [Self-Correction Guidance]:\n\
+            • Cause: Target code has drifted or modified. Closest match found at lines {best_line}–{end_line} ({pct}% similarity).\n\
+            • Current File Snippet (lines {best_line}+):\n\
+            ```\n\
+            {sample_snippet}\n\
+            ```\n\
+            • Recommended Action: Call 'read_file' with path=\"{path_display}\", start_line={best_line}, end_line={suggested_end} \
+            to review current contents, then re-create the patch hunk with the actual code."
+        )
+    } else {
+        let total_lines = file_lines.len();
+        format!(
+            "Error: patch hunk {hunk_index} old text was not found in {path_display} ({total_lines} lines total)\n\n\
+            [Self-Correction Guidance]:\n\
+            • Cause: The specified old text does not match any region in '{path_display}'.\n\
+            • Recommended Action: Call 'read_file' on '{path_display}' to locate the target section, or use 'search_code' \
+            to check if the target function or variable was moved to another file."
+        )
+    }
+}
+
+/// Formats ambiguous patch matches with exact line numbers.
+pub fn format_ambiguous_patch_guidance(
+    file_content: &str,
+    old_text: &str,
+    hunk_index: usize,
+    path: &Path,
+    occurrences: usize,
+) -> String {
+    let path_display = path.display();
+    let mut matching_lines = Vec::new();
+    let old_first_line = old_text.lines().next().unwrap_or("").trim();
+
+    for (idx, line) in file_content.lines().enumerate() {
+        if line.contains(old_first_line) && !old_first_line.is_empty() {
+            matching_lines.push(idx + 1);
+        }
+    }
+
+    let lines_str = if matching_lines.is_empty() {
+        format!("{occurrences} different locations")
+    } else {
+        matching_lines
+            .iter()
+            .take(6)
+            .map(|l| format!("line {l}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+
+    format!(
+        "Error: patch hunk {hunk_index} old text matches {occurrences} locations in {path_display} ({lines_str})\n\n\
+        [Self-Correction Guidance]:\n\
+        • Cause: Non-unique replacement target. The model provided too few surrounding context lines.\n\
+        • Recommended Actions:\n\
+          1. To modify a single specific location: add 2–3 unique lines of surrounding code above and below 'old_text'.\n\
+          2. To replace every occurrence across the file: set 'replaceAll': true on the hunk."
+    )
+}
+
+/// Analyzes shell execution output and extracts language-specific compiler/runtime error pointers.
+pub fn diagnose_command_failure(
+    command: &str,
+    output: &str,
+    exit_code: Option<i32>,
+) -> Option<String> {
+    let code_str = exit_code
+        .map(|c| format!("exit code {c}"))
+        .unwrap_or_else(|| "non-zero exit".into());
+
+    // 1. Rust compiler error detection (rustc / cargo)
+    if command.contains("cargo") || output.contains("error[E") {
+        for line in output.lines() {
+            if line.contains("error[E") {
+                let err_msg = line.trim();
+                // Find file pointer in subsequent lines
+                let location = output.lines().find(|l| l.trim().starts_with("--> "));
+                let loc_str = location
+                    .map(|l| format!(" at {}", l.trim().trim_start_matches("--> ")))
+                    .unwrap_or_default();
+
+                return Some(format!(
+                    "[Self-Correction Guidance — Rust Compilation Error ({code_str})]:\n\
+                    • Error: {err_msg}{loc_str}\n\
+                    • Recommended Action: Inspect the file and line indicated above using 'read_file', fix the syntax/type error using 'apply_patch', and re-run the build command."
+                ));
+            }
+        }
+    }
+
+    // 2. TypeScript / Node compiler error detection
+    if command.contains("tsc") || output.contains("error TS") {
+        for line in output.lines() {
+            if line.contains("error TS") {
+                let err_msg = line.trim();
+                return Some(format!(
+                    "[Self-Correction Guidance — TypeScript Error ({code_str})]:\n\
+                    • Error: {err_msg}\n\
+                    • Recommended Action: Open the offending file with 'read_file', correct the typing issue, and verify with 'npm run typecheck' or 'tsc'."
+                ));
+            }
+        }
+    }
+
+    // 3. Python Traceback detection
+    if output.contains("Traceback (most recent call last):") {
+        let lines: Vec<&str> = output.lines().collect();
+        let last_exc = lines.iter().rev().find(|l| {
+            l.contains("Error:") || l.contains("Exception:") || l.starts_with("SyntaxError")
+        });
+        let last_file_line = lines.iter().rev().find(|l| l.trim().starts_with("File \""));
+
+        if let Some(exc) = last_exc {
+            let loc = last_file_line
+                .map(|l| format!(" ({})", l.trim()))
+                .unwrap_or_default();
+            return Some(format!(
+                "[Self-Correction Guidance — Python Runtime Exception ({code_str})]:\n\
+                • Exception: {}{loc}\n\
+                • Recommended Action: Read the traceback location using 'read_file', patch the root cause, and re-run your test command.",
+                exc.trim()
+            ));
+        }
+    }
+
+    None
+}
+
+/// Computes token-level Jaccard similarity between two strings.
+fn jaccard_similarity(a: &str, b: &str) -> f64 {
+    use std::collections::BTreeSet;
+    let tokens_a: BTreeSet<&str> = a.split_whitespace().collect();
+    let tokens_b: BTreeSet<&str> = b.split_whitespace().collect();
+
+    if tokens_a.is_empty() && tokens_b.is_empty() {
+        return 1.0;
+    }
+    if tokens_a.is_empty() || tokens_b.is_empty() {
+        return 0.0;
+    }
+
+    let intersection_count = tokens_a.intersection(&tokens_b).count();
+    let union_count = tokens_a.union(&tokens_b).count();
+
+    intersection_count as f64 / union_count as f64
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn detects_whitespace_and_indentation_mismatch() {
+        let file_content = "fn main() {\n    let count = 42;\n    println!(\"{}\", count);\n}\n";
+        // Target has different indentation (2 spaces instead of 4)
+        let old_text = "fn main() {\n  let count = 42;\n  println!(\"{}\", count);\n}\n";
+        let path = PathBuf::from("src/main.rs");
+
+        let guidance = format_patch_not_found_guidance(file_content, old_text, 1, &path);
+        assert!(guidance.contains("Whitespace or indentation mismatch detected"));
+        assert!(guidance.contains("Recommended Action"));
+        assert!(guidance.contains("read_file"));
+    }
+
+    #[test]
+    fn fuzzy_similarity_pinpoints_drift() {
+        let file_content =
+            "line 1\nline 2\nlet total = calculate_sum(items, tax);\nlet discount = 0.1;\nline 5\n";
+        // Target text has slight drift
+        let old_text = "let total = calculate_sum(items);\nlet discount = 0.1;";
+        let path = PathBuf::from("src/lib.rs");
+
+        let guidance = format_patch_not_found_guidance(file_content, old_text, 1, &path);
+        assert!(guidance.contains("Closest match found at lines"));
+        assert!(guidance.contains("similarity"));
+    }
+
+    #[test]
+    fn formats_ambiguous_matches_with_lines() {
+        let file_content = "let x = 1;\nlet y = 2;\nlet x = 1;\n";
+        let old_text = "let x = 1;\n";
+        let path = PathBuf::from("src/test.rs");
+
+        let guidance = format_ambiguous_patch_guidance(file_content, old_text, 1, &path, 2);
+        assert!(guidance.contains("matches 2 locations"));
+        assert!(guidance.contains("line 1, line 3"));
+        assert!(guidance.contains("replaceAll"));
+    }
+
+    #[test]
+    fn extracts_rust_compiler_error_diagnostics() {
+        let output = "\
+error[E0425]: cannot find value `foo` in this scope
+  --> src/main.rs:12:5
+   |
+12 |     foo();
+   |     ^^^ not found in this scope
+";
+        let diag = diagnose_command_failure("cargo check", output, Some(101));
+        assert!(diag.is_some());
+        let msg = diag.unwrap();
+        assert!(msg.contains("Rust Compilation Error"));
+        assert!(msg.contains("cannot find value `foo` in this scope"));
+        assert!(msg.contains("src/main.rs:12:5"));
+    }
+
+    #[test]
+    fn extracts_python_traceback_diagnostics() {
+        let output = "\
+Traceback (most recent call last):
+  File \"app/server.py\", line 45, in run
+    raise ValueError(\"invalid port\")
+ValueError: invalid port
+";
+        let diag = diagnose_command_failure("python3 app/server.py", output, Some(1));
+        assert!(diag.is_some());
+        let msg = diag.unwrap();
+        assert!(msg.contains("Python Runtime Exception"));
+        assert!(msg.contains("ValueError: invalid port"));
+        assert!(msg.contains("app/server.py"));
+    }
+}

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

@@ -0,0 +1,379 @@
+use super::*;
+
+#[tokio::test]
+async fn parallel_image_reads_preserve_pixels_for_each_model_tool_call() {
+    let root = std::env::temp_dir().join(format!("mint-image-batch-{}", uuid::Uuid::new_v4()));
+    std::fs::create_dir_all(&root).unwrap();
+    image::RgbImage::new(4, 3)
+        .save(root.join("source.png"))
+        .unwrap();
+    let mut config = MintConfig::default();
+    config.allowed_read_paths.push(root.clone());
+    let decisions: Vec<_> = (0..2)
+        .map(|index| {
+            (
+                format!("image-{index}"),
+                AgentDecision {
+                    thought: String::new(),
+                    action: "view_image".into(),
+                    input: AgentInput {
+                        path: "source.png".into(),
+                        ..Default::default()
+                    },
+                },
+            )
+        })
+        .collect();
+    let mut images = std::collections::HashMap::new();
+    let mut artifacts = Vec::new();
+    let results = run_parallel_read_only_batch(
+        &decisions,
+        1,
+        &root,
+        &config,
+        "batch-images",
+        &mut |_| Ok(ApprovalOutcome::Approved),
+        &mut |event| {
+            if let AgentProgress::ToolArtifacts {
+                artifacts: entries, ..
+            } = event
+            {
+                artifacts.extend(entries);
+            }
+        },
+        &mut BTreeMap::new(),
+        &mut Vec::new(),
+        &mut images,
+        &[],
+        None,
+        true,
+    )
+    .await;
+    let directory = crate::mcp_result::artifact_directory().unwrap();
+    for entry in artifacts {
+        let _ = std::fs::remove_file(directory.join(&entry.id));
+        let _ = std::fs::remove_file(directory.join(format!("{}.json", entry.id)));
+    }
+    let _ = std::fs::remove_dir_all(root);
+    assert_eq!(results.len(), 2);
+    assert_eq!(images.get("image-0").map(Vec::len), Some(1));
+    assert_eq!(images.get("image-1").map(Vec::len), Some(1));
+}
+
+#[test]
+fn deleting_a_conversation_removes_only_its_image_artifacts() {
+    let mut bytes = std::io::Cursor::new(Vec::new());
+    image::RgbImage::new(2, 2)
+        .write_to(&mut bytes, image::ImageFormat::Png)
+        .unwrap();
+    let owner = format!("image-delete-{}", uuid::Uuid::new_v4());
+    let image = crate::media::tool_images::save(
+        bytes.get_ref(),
+        "image/png",
+        "result.png",
+        &owner,
+        "call",
+        "browser",
+        None,
+    )
+    .unwrap();
+    let other = crate::media::tool_images::save(
+        bytes.get_ref(),
+        "image/png",
+        "other.png",
+        &format!("{owner}-other"),
+        "call",
+        "browser",
+        None,
+    )
+    .unwrap();
+    let artifact = &image.artifacts[0];
+    let database =
+        std::env::temp_dir().join(format!("mint-image-delete-{}.sqlite", uuid::Uuid::new_v4()));
+    let memory = MemoryStore::open(&database);
+    memory.delete_chat_session(&owner).unwrap();
+    let present = crate::mcp_result::read_artifact(&artifact.id).is_ok();
+    let other_present = crate::mcp_result::read_artifact(&other.artifacts[0].id).is_ok();
+    let directory = crate::mcp_result::artifact_directory().unwrap();
+    let _ = std::fs::remove_file(directory.join(&artifact.id));
+    let _ = std::fs::remove_file(directory.join(format!("{}.json", artifact.id)));
+    let _ = std::fs::remove_file(directory.join(&other.artifacts[0].id));
+    let _ = std::fs::remove_file(directory.join(format!("{}.json", other.artifacts[0].id)));
+    let _ = std::fs::remove_file(database);
+    assert!(!present, "deleted conversation left its screenshot on disk");
+    assert!(
+        other_present,
+        "deleting one chat removed another chat's image"
+    );
+}
+
+#[tokio::test]
+async fn viewed_images_have_durable_artifacts_and_separate_model_pixels() {
+    let root = std::env::temp_dir().join(format!("mint-image-outcome-{}", uuid::Uuid::new_v4()));
+    std::fs::create_dir_all(&root).unwrap();
+    image::RgbImage::new(4, 3)
+        .save(root.join("source.png"))
+        .unwrap();
+    let mut config = MintConfig::default();
+    config.allowed_read_paths.push(root.clone());
+    let decision = AgentDecision {
+        thought: String::new(),
+        action: "view_image".into(),
+        input: AgentInput {
+            path: "source.png".into(),
+            ..Default::default()
+        },
+    };
+    let outcome = execute_tool_outcome_reviewed(
+        &root,
+        &config,
+        &decision,
+        "image-owner",
+        &mut |_| Ok(ApprovalOutcome::Approved),
+        &mut |_| {},
+        "image-call",
+        None,
+    )
+    .await
+    .unwrap();
+    let _ = std::fs::remove_dir_all(root);
+    assert_eq!(outcome.images.len(), 1);
+    assert_eq!(outcome.artifacts.len(), 1);
+    assert!(!outcome.text.contains("base64"));
+    let artifact = &outcome.artifacts[0];
+    let (_, bytes) = crate::mcp_result::read_artifact(&artifact.id).unwrap();
+    assert!(image::load_from_memory(&bytes).is_ok());
+    assert!(crate::media::tool_images::view_artifact(&artifact.id, "different-chat").is_err());
+    assert_eq!(
+        crate::media::tool_images::view_artifact(&artifact.id, "image-owner")
+            .unwrap()
+            .images
+            .len(),
+        1
+    );
+    let directory = crate::mcp_result::artifact_directory().unwrap();
+    let _ = std::fs::remove_file(directory.join(&artifact.id));
+    let _ = std::fs::remove_file(directory.join(format!("{}.json", artifact.id)));
+}
+
+#[tokio::test]
+async fn orchestration_prunes_older_tool_images_while_preserving_recent_images() {
+    let mut messages = Vec::new();
+    let mut images_1 = std::collections::HashMap::new();
+    images_1.insert("call-1".into(), vec!["data:image/png;base64,step1".into()]);
+    let results_1 = vec![ToolResultEntry {
+        call_id: "call-1".into(),
+        action: "view_image".into(),
+        input: serde_json::json!({ "path": "step1.png" }),
+        text: "[Image loaded — see attached image]".into(),
+        status: crate::mcp_result::ToolStatus::Success,
+    }];
+    append_native_tool_results(
+        &mut messages,
+        "view step 1",
+        &results_1,
+        &Default::default(),
+        &images_1,
+    );
+    prune_historic_images_from_native_messages(&mut messages, MAX_RETAINED_IMAGE_STEPS);
+
+    // Step 1: Image is retained (1 step <= MAX_RETAINED_IMAGE_STEPS)
+    assert!(
+        messages[1]
+            .content
+            .iter()
+            .any(|b| matches!(b, ContentBlock::Image { .. }))
+    );
+
+    let mut images_2 = std::collections::HashMap::new();
+    images_2.insert("call-2".into(), vec!["data:image/png;base64,step2".into()]);
+    let results_2 = vec![ToolResultEntry {
+        call_id: "call-2".into(),
+        action: "view_image".into(),
+        input: serde_json::json!({ "path": "step2.png" }),
+        text: "[Image loaded — see attached image]".into(),
+        status: crate::mcp_result::ToolStatus::Success,
+    }];
+    append_native_tool_results(
+        &mut messages,
+        "view step 2",
+        &results_2,
+        &Default::default(),
+        &images_2,
+    );
+    prune_historic_images_from_native_messages(&mut messages, MAX_RETAINED_IMAGE_STEPS);
+
+    // Step 2: Both images retained (2 steps <= MAX_RETAINED_IMAGE_STEPS)
+    assert!(
+        messages[1]
+            .content
+            .iter()
+            .any(|b| matches!(b, ContentBlock::Image { .. }))
+    );
+    assert!(
+        messages[3]
+            .content
+            .iter()
+            .any(|b| matches!(b, ContentBlock::Image { .. }))
+    );
+
+    let mut images_3 = std::collections::HashMap::new();
+    images_3.insert("call-3".into(), vec!["data:image/png;base64,step3".into()]);
+    let results_3 = vec![ToolResultEntry {
+        call_id: "call-3".into(),
+        action: "view_image".into(),
+        input: serde_json::json!({ "path": "step3.png" }),
+        text: "[Image loaded — see attached image]".into(),
+        status: crate::mcp_result::ToolStatus::Success,
+    }];
+    append_native_tool_results(
+        &mut messages,
+        "view step 3",
+        &results_3,
+        &Default::default(),
+        &images_3,
+    );
+    let pruned =
+        prune_historic_images_from_native_messages(&mut messages, MAX_RETAINED_IMAGE_STEPS);
+
+    // Step 3: Step 1's image is pruned! Steps 2 and 3 are retained.
+    assert_eq!(pruned, 1);
+    assert!(
+        !messages[1]
+            .content
+            .iter()
+            .any(|b| matches!(b, ContentBlock::Image { .. }))
+    );
+    assert!(
+        messages[3]
+            .content
+            .iter()
+            .any(|b| matches!(b, ContentBlock::Image { .. }))
+    );
+    assert!(
+        messages[5]
+            .content
+            .iter()
+            .any(|b| matches!(b, ContentBlock::Image { .. }))
+    );
+    assert!(messages[1].content.iter().any(|b| matches!(b, ContentBlock::ToolResult { content, .. } if content.contains("historical image pixels pruned from context"))));
+}
+
+#[tokio::test]
+async fn view_image_and_read_file_can_access_temp_directory_safely() {
+    let workspace = std::env::temp_dir().join(format!("mint-workspace-{}", uuid::Uuid::new_v4()));
+    std::fs::create_dir_all(&workspace).unwrap();
+
+    // 1. Create an image and a text file in std::env::temp_dir() outside the workspace
+    let temp_img =
+        std::env::temp_dir().join(format!("mint-temp-test-{}.png", uuid::Uuid::new_v4()));
+    image::RgbImage::new(10, 10).save(&temp_img).unwrap();
+
+    let temp_txt =
+        std::env::temp_dir().join(format!("mint-temp-note-{}.txt", uuid::Uuid::new_v4()));
+    std::fs::write(&temp_txt, "Hello from /tmp!").unwrap();
+
+    let config = MintConfig::default();
+    let mut approve = |_appr: &AgentApproval| Ok(ApprovalOutcome::Approved);
+
+    // 2. Test view_image with absolute temp path
+    let img_input = AgentInput {
+        path: temp_img.to_string_lossy().to_string(),
+        ..Default::default()
+    };
+    let img_res = tools::project::execute(
+        "view_image",
+        &img_input,
+        &workspace,
+        &config,
+        "test-chat",
+        &mut approve,
+    )
+    .await;
+    assert!(
+        img_res.is_ok(),
+        "view_image failed on temp file: {:?}",
+        img_res.err()
+    );
+    let img_out = img_res.unwrap();
+    assert!(img_out.starts_with("data:image/png;base64,"));
+
+    // 3. Test read_file with absolute temp path
+    let txt_input = AgentInput {
+        path: temp_txt.to_string_lossy().to_string(),
+        ..Default::default()
+    };
+    let txt_res = tools::files::execute(
+        "read_file",
+        &txt_input,
+        &workspace,
+        &config,
+        "test-chat",
+        &mut approve,
+    )
+    .await;
+    assert!(
+        txt_res.is_ok(),
+        "read_file failed on temp file: {:?}",
+        txt_res.err()
+    );
+    let txt_out = txt_res.unwrap();
+    assert!(txt_out.contains("Hello from /tmp!"));
+
+    // 4. Test security: sensitive files like .env remain blocked even in temp
+    let temp_sub = std::env::temp_dir().join(format!("mint-sub-{}", uuid::Uuid::new_v4()));
+    std::fs::create_dir_all(&temp_sub).unwrap();
+    let blocked_file = temp_sub.join(".env");
+    std::fs::write(&blocked_file, "SECRET=123").unwrap();
+
+    let blocked_input = AgentInput {
+        path: blocked_file.to_string_lossy().to_string(),
+        ..Default::default()
+    };
+    let blocked_res = tools::files::execute(
+        "read_file",
+        &blocked_input,
+        &workspace,
+        &config,
+        "test-chat",
+        &mut approve,
+    )
+    .await;
+    assert!(
+        blocked_res.is_err(),
+        "reading .env from temp should be blocked"
+    );
+
+    // 5. Test orchestration::execute_tool interception path for view_image with /tmp (regression for mod.rs:3713)
+    let decision = AgentDecision {
+        thought: "view temp image".into(),
+        action: "view_image".into(),
+        input: AgentInput {
+            path: temp_img.to_string_lossy().to_string(),
+            ..Default::default()
+        },
+    };
+    let mut progress_cb = |_p: AgentProgress| {};
+    let outcome = execute_tool(
+        &workspace,
+        &config,
+        &decision,
+        "test-chat",
+        &mut approve,
+        &mut progress_cb,
+    )
+    .await;
+    assert!(
+        outcome.is_ok(),
+        "orchestration execute_tool failed on temp image: {:?}",
+        outcome.err()
+    );
+    let outcome = outcome.unwrap();
+    assert!(outcome.contains("Image saved:"));
+
+    // Clean up
+    let _ = std::fs::remove_file(temp_img);
+    let _ = std::fs::remove_file(temp_txt);
+    let _ = std::fs::remove_dir_all(temp_sub);
+    let _ = std::fs::remove_dir_all(workspace);
+}