@pheem49/mint 1.17.0 → 1.18.0

package/crates/mint-core/src/prompts/agent.rs

@@ -1,14 +1,6 @@
 use super::persona;
 use crate::MintConfig;
 
-pub(crate) fn browser_tools_enabled(config: &MintConfig) -> bool {
-    config
-        .extra
-        .get("browserAutomationEnabled")
-        .and_then(serde_json::Value::as_bool)
-        != Some(false)
-}
-
 pub(crate) const PLAN_MODE_ALLOWED_ACTIONS: &[&str] = &[
     "list_files",
     "read_file",
@@ -146,10 +138,6 @@ pub fn build_system_prompt(
 ) -> String {
     let mut allowed_actions = base_allowed_actions();
 
-    if browser_tools_enabled(config) {
-        allowed_actions.extend_from_slice(crate::browser::BROWSER_TOOLS);
-    }
-
     if !config.avatar_token.is_empty() {
         allowed_actions.push("avatar_signal");
     }
@@ -236,34 +224,6 @@ pub fn build_system_prompt(
     if allowed_actions.contains(&"calculation") {
         input_formats.push("- calculation: {\"expression\":\"math or percentage expression e.g. 25% of 8500 or 100 * 3.5\"}");
     }
-    if allowed_actions.contains(&"browser_open") {
-        input_formats.push("- browser_open: {\"url\":\"https://example.com\"}");
-    }
-    if allowed_actions.contains(&"browser_observe") {
-        input_formats.push("- browser_observe: {textOffset?:number,elementOffset?:number,takeoverComplete?:boolean}; browser_tabs: {operation:list|open|select|close,tabId?:string,url?:string}; browser_fill: {elementRef?:string,selector?:string,text:string}; browser_select: {elementRef?:string,selector?:string,value:string}; browser_scroll: {elementRef?:string,selector?:string,x?:number,y?:number}; browser_wait: {condition:url|text|visible|hidden,value?:string,elementRef?:string,selector?:string,timeoutMs?:number}. browser_click/browser_type also accept elementRef instead of selector.");
-    }
-    if allowed_actions.contains(&"browser_click") {
-        input_formats.push("- browser_click: {\"selector\":\"button.submit-btn\"} (CSS selector, or text=Login, contains=Submit, xpath=//button)");
-    }
-    if allowed_actions.contains(&"browser_type") {
-        input_formats
-            .push("- browser_type: {\"selector\":\"input.search-bar\", \"text\":\"search query\"} (CSS selector, or text=Placeholder, contains=Label)");
-    }
-    if allowed_actions.contains(&"browser_read") {
-        input_formats.push("- browser_read: {}");
-    }
-    if allowed_actions.contains(&"browser_mouse_move") {
-        input_formats.push("- browser_mouse_move: {\"x\":640,\"y\":360}");
-    }
-    if allowed_actions.contains(&"browser_mouse_click") {
-        input_formats.push("- browser_mouse_click: {\"x\":640,\"y\":360,\"button\":\"left\"}");
-    }
-    if allowed_actions.contains(&"browser_key_press") {
-        input_formats.push("- browser_key_press: {\"key\":\"Enter\"} (keys: Enter,Tab,Escape,Backspace,Delete,ArrowUp,ArrowDown,ArrowLeft,ArrowRight,F1-F12,Space)");
-    }
-    if allowed_actions.contains(&"browser_screenshot") {
-        input_formats.push("- browser_screenshot: {mode?:viewport|fullPage|element,selector?:string,elementRef?:string}");
-    }
     if allowed_actions.contains(&"memory_recall") {
         input_formats.push("- memory_recall: {\"query\":\"what did user say about X\"}");
     }
@@ -489,7 +449,7 @@ pub fn build_system_prompt(
         rules.push("4. Shell commands and file edits require user approval. Mint handles approval after you request the tool.");
         rules.push("4a. SKILL CHANGES: Create or edit reusable skills only when the user asks for that work. Otherwise complete the current task and suggest the skill in your summary. Use write_file or apply_patch for skill files so Mint can show the concrete diff and request approval for each change. A general file or session permission does not authorize changing persistent skill instructions. After approval, report the saved skill path and what changed.");
     }
-    rules.push("Execution evidence: distinguish succeeded, failed, running, cancelled and unknown. Inspect background jobs with shell_output before claiming completion. Retry a command after relevant changes or with retryReason, but observe ambiguous side effects before repeating them. finish.completionStatus must be verified, unverified, blocked or failed; a verification explanation cannot override failed or pending checks. When checks cannot run, finish honestly with unverified/blocked and the reason. Opening a browser or starting a process completes only that step, not the user's entire task.");
+    rules.push("Execution evidence: distinguish succeeded, failed, running, cancelled and unknown. Inspect background jobs with shell_output before claiming completion. When a command reports running_in_background, the process is actively executing — do not restart or retry it with an alternative approach. Retry a command after relevant changes or with retryReason, but observe ambiguous side effects before repeating them. finish.completionStatus must be verified, unverified, blocked or failed; a verification explanation cannot override failed or pending checks. When checks cannot run, finish honestly with unverified/blocked and the reason. Opening a browser or starting a process completes only that step, not the user's entire task.");
     if allowed_actions.contains(&"run_shell") {
         rules.push("5. Shell commands are classified as readOnly, test, network, or mutating. Only policy-allowed modes may run after approval. Never request destructive commands such as rm -rf, git reset --hard, git checkout --, or git clean -f.");
     }
@@ -497,7 +457,9 @@ pub fn build_system_prompt(
         rules.push("6. Verify code changes when possible. If compile or test commands fail (exit status is not 0), analyze the stdout/stderr to locate the bug, edit the code to fix it, and verify again. Do not stop or give up until the errors are resolved.");
     }
     if allowed_actions.contains(&"web_search") {
-        rules.push("7. Use web_search when the user asks to look something up online or needs current information.");
+        rules.push("7. Use web_search when the user asks to look something up online or needs current information.\n\
+- Information Sufficiency: If web_search results already contain the direct answer, official links, social profiles, or overview the user asked for, synthesize the final answer and call `finish` immediately. Do NOT run redundant searches or launch headless Chrome.\n\
+- Follow-up Gate: If search results are incomplete, ambiguous, or if further research could be explored, DO NOT run arbitrary loops or crawl pages autonomously. Instead, summarize what you found so far and call `ask_user` with clear options to confirm whether the user wants to search further and what specific topics or links to explore next.");
     }
     if allowed_actions.contains(&"image_search") {
         rules.push("7i. Use image_search when the user explicitly wants to see, browse, or find pictures/photos of something. Do NOT use it just to decorate a text answer — web_search already attaches a thumbnail automatically when relevant. ALWAYS copy the ```image_search_json ... ``` block from the tool observation into your final summary text so the UI card renders.");
@@ -517,37 +479,8 @@ pub fn build_system_prompt(
     if allowed_actions.contains(&"avatar_signal") {
         rules.push("7v. A Project Avatar is connected. Call avatar_signal when your reply carries an emotional beat the automatic tool-based reactions can't express — greeting, joking, apologizing, thinking something over. Don't call it for routine tool-driven turns (shell, browser, image/video generation); those already react on their own.");
     }
-    if allowed_actions.contains(&"run_shell") && !allowed_actions.contains(&"browser_open") {
-        rules.push("7a. For browsing, viewing, or capturing websites/webpages: use run_shell to run headless browser commands directly (e.g. google-chrome --headless=new --screenshot=screenshot.png <url>). ALWAYS call view_image with the generated image path (e.g. view_image(path: \"screenshot.png\")) immediately after capturing a screenshot so you and the user can inspect the visual result. Do NOT write ad-hoc Python scraping scripts (urllib, requests) or raw curl to scrape modern web pages when browser tools or headless chrome commands are available.");
-    }
-    if allowed_actions.contains(&"browser_open") {
-        rules.push("7a. Use browser_open to open websites; Mint starts an isolated browser session automatically (headless by default). Inspect the returned page observation, then use browser_observe/browser_read to read the page or browser_screenshot for visual inspection; verify the requested URL/content with browser_wait before finishing. A successful browser_open already opens the website for the user: do not also launch it through run_shell, xdg-open, open, Start-Process, or another browser. Keep website navigation and interaction in the automation browser. If the user explicitly requests an external browser, use that route instead of first opening the website in automation. If automation is unavailable or blocked, report that and ask the user before switching browsers. For a predefined command-line workflow, write a JSON steps file and run mint browser run --file <file> through run_shell; --headed explicitly shows its window. Use the shared engine rather than hand-written browser scripts. Web scraping restriction: NEVER write ad-hoc Python scripts (e.g., using urllib, requests, BeautifulSoup) or raw curl commands to scrape or inspect web pages. Modern websites require JavaScript rendering via the browser engine. Always prioritize browser_open when given a web URL.");
-    }
-    if allowed_actions.contains(&"browser_click") {
-        rules.push("7b. Use browser_click to click elements. Selector can be: CSS selector (button.class, #id, [attr=val]), text=ExactText to find by visible text, contains=PartialText for partial match, or xpath=//expr for XPath. Prefer text= or contains= when the element has visible text but no unique CSS class.");
-    }
-    if allowed_actions.contains(&"browser_type") {
-        rules.push("7c. Use browser_type to enter text into form fields or search boxes. Selector supports the same formats as browser_click.");
-    }
-    if allowed_actions.contains(&"browser_read") {
-        rules.push(
-            "7d. Use browser_read to read the text content of the active page to analyze it.",
-        );
-    }
-    if allowed_actions.contains(&"browser_mouse_move") {
-        rules.push("7e. Use browser_mouse_move to move the real mouse cursor to absolute (x,y) coordinates.");
-    }
-    if allowed_actions.contains(&"browser_mouse_click") {
-        rules.push("7f. Use browser_mouse_click to perform a native mouse click at (x,y) coordinates. Use browser_screenshot first to find the target position.");
-    }
-    if allowed_actions.contains(&"browser_key_press") {
-        rules.push("7g. Use browser_key_press to press a keyboard key (e.g. Enter, Tab, Escape, ArrowDown). Use after browser_type or browser_mouse_click to interact with focused elements.");
-    }
-    if allowed_actions.contains(&"browser_screenshot") {
-        rules.push("7h. Use browser_screenshot to capture the page as a durable image artifact, shown in chat and attached to the model. Use it to inspect the visual state of the page before deciding where to click, and to capture visual verification of page content for the user.");
-    }
-    if allowed_actions.contains(&"browser_observe") {
-        rules.push("7i. Browser workflow: browser_observe -> action -> inspect the returned observation -> verify the expected result with browser_wait. Each run starts in its own tab. Use browser_tabs to list/open/select/close tabs; select new popup tabs explicitly. Prefer elementRef from the most recent observation over guessing selectors. Old refs expire after observation refresh, navigation, removed nodes, or tab selection. browser_fill replaces text; browser_type appends. browser_select handles native dropdowns; browser_scroll scrolls the viewport or a target. browser_wait accepts condition url/text/visible/hidden, value or target, and timeoutMs (default 10000, maximum 30000). Observations support textOffset and elementOffset pagination. Coordinate actions require a screenshot of the selected tab within 30 seconds. Never retry an ambiguous click or submission automatically; observe and check the result first. input_dispatched is not task completion. Cite observed URL/text/field evidence in finish.verification, or say the task is unverified/blocked. Age Gate & Cookie Consent Handling: If an age gate (18+ confirmation), cookie banner, or disclaimer modal blocks page content, locate standard confirmation buttons (e.g. \"I am 18 or older\", \"Enter Site\", \"Yes\", \"Agree\", \"Accept\") and dismiss it using browser_click. If the overlay presents sensitive warnings requiring explicit user discretion or consent, capture a browser_screenshot and use ask_user to confirm before proceeding. If blocked by login, CAPTCHA, or repeated lack of progress, ask_user for manual takeover; only after user confirmation call browser_observe with takeoverComplete=true.");
+    if allowed_actions.contains(&"run_shell") {
+        rules.push("7a. Headless Chrome through run_shell is for deep webpage inspection or rendering, NOT for routine web searches. Use it ONLY when: (a) the user explicitly requests inspecting, reading, or scraping a specific webpage/URL, (b) web_search snippets were blocked or insufficient and direct page reading is required, or (c) rendering local HTML. Never recursively crawl external links found on a page. Mint adds the reliability flags, a throw-away profile and a timeout for you, so write the plain command. (1) Read a page first with `google-chrome --dump-dom <url>` (runs JavaScript, so SPAs work; far cheaper than an image). (2) Only when the visual layout matters: `google-chrome --screenshot=<file>.png <url>` (add --window-size=W,H for a tall or narrow view), then call view_image with that path exactly once per image; a repeated image is not attached again. (3) Never capture the same URL with the same options twice in a turn; Mint refuses repeats unless you pass retryReason because the page really changed. If a result is not what you need, change the URL or options instead of repeating. (4) For clicking, typing or multi-step flows, write a JSON steps file and run `mint browser run --file <file>`. Do NOT scrape modern pages with ad-hoc Python (urllib, requests) or raw curl.");
     }
     if allowed_actions.contains(&"memory_recall") {
         rules.push("8. Use memory_recall to search past interactions before asking the user to repeat context.");
@@ -591,14 +524,13 @@ For every JSON-backed card, ensure all properties stay inside their intended obj
 - Feature showcases: use fenced ```ui-card with JSON array:\n```ui-card\n[{\"title\": \"...\", \"subtitle\": \"...\", \"icon\": \"file-text\", \"badge\": \"...\", \"details\": {\"Key\": \"Value\"}}]\n```\n\
 - UI Prototypes: use fenced ```ui-mockup with JSON object:\n```ui-mockup\n{\"title\": \"...\", \"subtitle\": \"...\", \"dropzoneText\": \"...\", \"metrics\": {...}}\n```\n\
 - Key insights / alerts: use GitHub callouts (> [!NOTE], > [!TIP], > [!IMPORTANT], > [!WARNING]). Always converse naturally and smoothly; never prefix conversational phrases or greetings with artificial status tags or badge pills. Always put opening and closing ``` fences on their own separate lines.");
-    if allowed_actions.contains(&"browser_open") {
-        rules.push("12. Shell commands may open local files/folders or launch apps when requested. For websites, follow rule 7a and verify the automation browser's observed page; a shell launch is not evidence that a browser task is complete.");
-    } else if native {
+    if native {
         rules.push("12. Commands that open URLs, files, folders, or launch apps (e.g. xdg-open, open) run in the background. Once they succeed (exit: 0), you are done. Use the finish tool immediately.");
     } else {
         rules.push("12. Commands that open URLs, files, folders, or launch apps (e.g. xdg-open, open) run in the background. Once they succeed (exit: 0), you are done. Use the 'finish' action immediately.");
     }
     rules.push("12a. Development servers and watchers must use run_shell with background: true so the tool returns a job_id immediately. For Python use python3 -u -m http.server <port>. Inspect shell_output and verify an HTTP response before claiming a server is ready; a job_id alone only proves it started. Keep existing background jobs alive when finishing a response or cancelling AI work, unless the user asks to stop them. Use kill_shell to stop only the requested job.");
+    rules.push("12b. When a command is moved to the background or reports running_in_background, the process is actively executing. NEVER rerun, rewrite, or switch approaches. You must use shell_output to await its completion.");
     let mature_rule = format!("13. {}", persona::MATURE_CONTENT_POLICY);
     rules.push(&mature_rule);
 
@@ -640,3 +572,47 @@ For every JSON-backed card, ensure all properties stay inside their intended obj
     }
     prompt
 }
+
+#[cfg(test)]
+mod headless_playbook_tests {
+    use super::*;
+
+    fn shell_mode_prompt() -> String {
+        let config = MintConfig::default();
+        build_system_prompt(&config, false, false, None, None)
+    }
+
+    #[test]
+    fn shell_mode_teaches_the_headless_chrome_playbook() {
+        let prompt = shell_mode_prompt();
+        for needle in [
+            "--dump-dom",
+            "--screenshot=",
+            "view_image",
+            "once per image",
+            "same URL",
+            "mint browser run",
+        ] {
+            assert!(prompt.contains(needle), "playbook is missing {needle:?}");
+        }
+        assert!(
+            !prompt.contains("browser_open"),
+            "no browser_* tools in shell mode"
+        );
+    }
+
+    #[test]
+    fn web_search_playbook_enforces_information_sufficiency_and_ask_user_gate() {
+        let prompt = shell_mode_prompt();
+        for needle in [
+            "Information Sufficiency",
+            "call `ask_user` with clear options",
+            "Never recursively crawl",
+        ] {
+            assert!(
+                prompt.contains(needle),
+                "web search playbook is missing {needle:?}"
+            );
+        }
+    }
+}

package/crates/mint-core/src/prompts/tool_catalog.rs

@@ -12,7 +12,7 @@ use std::path::Path;
 
 use serde_json::{Value, json};
 
-use super::agent::{PLAN_MODE_ALLOWED_ACTIONS, base_allowed_actions, browser_tools_enabled};
+use super::agent::{PLAN_MODE_ALLOWED_ACTIONS, base_allowed_actions};
 use crate::MintConfig;
 use crate::chat::ToolSpec;
 use crate::subagents::list_subagents;
@@ -54,9 +54,6 @@ pub fn tool_catalog(
     allow_subagent_dispatch: bool,
 ) -> Vec<ToolSpec> {
     let mut allowed = base_allowed_actions();
-    if browser_tools_enabled(config) {
-        allowed.extend_from_slice(crate::browser::BROWSER_TOOLS);
-    }
     if !config.avatar_token.is_empty() && !config.avatar_signal_disabled {
         allowed.push("avatar_signal");
     }
@@ -356,121 +353,6 @@ fn all_tools() -> Vec<ToolSpec> {
                 &["expression"],
             ),
         ),
-        tool(
-            "browser_open",
-            "Navigate the automation browser to a URL.",
-            schema(json!({ "url": { "type": "string" } }), &["url"]),
-        ),
-        tool(
-            "browser_click",
-            "Click an observed element. Provide elementRef or selector, not both.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"}}),
-                &[],
-            ),
-        ),
-        tool(
-            "browser_type",
-            "Append text to a field. Provide elementRef or selector, not both.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"text":{"type":"string"}}),
-                &["text"],
-            ),
-        ),
-        tool(
-            "browser_fill",
-            "Replace a field's value and verify it.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"text":{"type":"string"}}),
-                &["text"],
-            ),
-        ),
-        tool(
-            "browser_select",
-            "Select a native dropdown option by value.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"value":{"type":"string"}}),
-                &["value"],
-            ),
-        ),
-        tool(
-            "browser_observe",
-            "Read structured page state and fresh element references. Confirm takeover only after the user has completed it.",
-            schema(
-                json!({"textOffset":{"type":"integer","minimum":0},"elementOffset":{"type":"integer","minimum":0},"takeoverComplete":{"type":"boolean"}}),
-                &[],
-            ),
-        ),
-        tool(
-            "browser_tabs",
-            "List/open/select/close tabs. Selection and closure require explicit tabId; popups are never auto-selected.",
-            schema(
-                json!({"operation":{"type":"string","enum":["list","open","select","close"]},"tabId":{"type":"string"},"url":{"type":"string"}}),
-                &["operation"],
-            ),
-        ),
-        tool(
-            "browser_scroll",
-            "Scroll the viewport or an observed element by pixels.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"x":{"type":"number"},"y":{"type":"number"}}),
-                &[],
-            ),
-        ),
-        tool(
-            "browser_wait",
-            "Wait for a URL, text, or element visibility condition; at most 30 seconds.",
-            schema(
-                json!({"condition":{"type":"string","enum":["url","text","visible","hidden"]},"value":{"type":"string"},"elementRef":{"type":"string"},"selector":{"type":"string"},"timeoutMs":{"type":"integer","minimum":1,"maximum":30000}}),
-                &["condition"],
-            ),
-        ),
-        tool(
-            "browser_read",
-            "Read the text content of the active browser page.",
-            schema(json!({}), &[]),
-        ),
-        tool(
-            "browser_mouse_move",
-            "Move the browser cursor to viewport (x, y) coordinates.",
-            schema(
-                json!({ "x": { "type": "number" }, "y": { "type": "number" } }),
-                &["x", "y"],
-            ),
-        ),
-        tool(
-            "browser_mouse_click",
-            "Perform a native mouse click at (x, y). Use browser_screenshot first to find the target position.",
-            schema(
-                json!({
-                    "x": { "type": "number" },
-                    "y": { "type": "number" },
-                    "button": { "type": "string", "description": "left | right | middle. Defaults to left." }
-                }),
-                &["x", "y"],
-            ),
-        ),
-        tool(
-            "browser_key_press",
-            "Press a keyboard key in the automation browser.",
-            schema(
-                json!({
-                    "key": {
-                        "type": "string",
-                        "description": "Enter, Tab, Escape, Backspace, Delete, ArrowUp/Down/Left/Right, F1-F12, Space, ..."
-                    }
-                }),
-                &["key"],
-            ),
-        ),
-        tool(
-            "browser_screenshot",
-            "Capture the current automation browser page as an image.",
-            schema(
-                json!({"mode":{"type":"string","enum":["viewport","fullPage","element"]},"selector":{"type":"string"},"elementRef":{"type":"string"}}),
-                &[],
-            ),
-        ),
         tool(
             "memory_recall",
             "Search past interactions/memory before asking the user to repeat context.",
@@ -1101,42 +983,17 @@ fn all_tools() -> Vec<ToolSpec> {
 mod browser_startup_tests {
     use super::*;
     #[test]
-    fn browser_tools_are_discoverable_when_browser_automation_enabled() {
-        let mut config = MintConfig::default();
+    fn browser_tools_are_superseded_by_shell_playbook() {
+        let config = MintConfig::default();
         let default_tools = tool_catalog(&config, false, Path::new("."), false);
-        // By default, browser tools are enabled out of the box for real web browsing.
-        assert!(default_tools.iter().any(|tool| tool.name == "browser_open"));
-
-        // Explicitly disabling browser automation removes browser tools.
-        config
-            .extra
-            .insert("browserAutomationEnabled".into(), json!(false));
-        let disabled_tools = tool_catalog(&config, false, Path::new("."), false);
-        assert!(
-            !disabled_tools
-                .iter()
-                .any(|tool| tool.name == "browser_open")
-        );
-
-        config
-            .extra
-            .insert("browserAutomationEnabled".into(), json!(true));
-        config.extra.insert(
-            "browserDebugUrl".into(),
-            json!("http://127.0.0.1:1/json/list"),
-        );
-        let tools = tool_catalog(&config, false, Path::new("."), false);
-        assert!(tools.iter().any(|tool| tool.name == "browser_open"));
-        assert!(
-            crate::prompts::agent::build_system_prompt(&config, false, false, None, None)
-                .contains("browser_open")
-        );
-        config.disabled_tools.push("browser_open".into());
+        // Agent browser_* tools are removed; web browsing is done via run_shell
+        assert!(!default_tools.iter().any(|tool| tool.name == "browser_open"));
         assert!(
-            !tool_catalog(&config, false, Path::new("."), false)
+            !default_tools
                 .iter()
-                .any(|tool| tool.name == "browser_open")
+                .any(|tool| tool.name == "browser_screenshot")
         );
+        assert!(default_tools.iter().any(|tool| tool.name == "run_shell"));
     }
 }
 

package/crates/mint-core/src/search/files.rs

@@ -108,6 +108,17 @@ pub fn resolve_readable_path(target: &str, workspace: Option<&Path>) -> PathBuf
                 candidates.push(ws.join(&norm_slash));
             }
             candidates.push(ws.join(trimmed));
+
+            // Defensively recover from duplicated workspace prefixes (e.g. /workspace/workspace/file)
+            let ws_norm = ws.to_string_lossy().replace('\\', "/");
+            let ws_clean = ws_norm.trim_end_matches('/');
+            if let Some(rest) = norm_slash.strip_prefix(ws_clean) {
+                let inner = rest.trim_start_matches('/');
+                if !inner.is_empty() {
+                    candidates.push(PathBuf::from(format!("/{}", inner)));
+                    candidates.push(PathBuf::from(inner));
+                }
+            }
         }
     }
 
@@ -304,6 +315,15 @@ mod tests {
         let resolved_win = resolve_readable_path("sub\\sample.md", Some(&temp_dir));
         assert_eq!(resolved_win, test_file);
 
+        // Duplicated workspace prefix recovery
+        let duplicated = format!(
+            "{}/{}",
+            temp_dir.to_string_lossy(),
+            test_file.to_string_lossy().trim_start_matches('/')
+        );
+        let resolved_dup = resolve_readable_path(&duplicated, Some(&temp_dir));
+        assert_eq!(resolved_dup, test_file);
+
         // Non-existent path returns fallback joined with workspace
         let missing = resolve_readable_path("missing.md", Some(&temp_dir));
         assert_eq!(missing, temp_dir.join("missing.md"));