@pheem49/mint 1.14.0 → 1.16.0

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

@@ -3,8 +3,8 @@ use std::path::Path;
 use super::super::*;
 
 /// Handles the subset of `execute_tool` actions related to browser.
-/// Only called for actions `execute_tool` has already routed here, so the
-/// fallback arm is unreachable in practice.
+/// Keeps legacy argument aliases at the orchestration seam; session behavior
+/// and browser result verification live in the shared browser module.
 pub(in crate::orchestration) async fn execute(
     action: &str,
     input: &AgentInput,
@@ -13,142 +13,19 @@ pub(in crate::orchestration) async fn execute(
     _chat_id: &str,
     _approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
-    match action {
-        "browser_open" => {
-            let url = if !input.url.is_empty() {
-                &input.url
-            } else if !input.path.is_empty() {
-                &input.path
-            } else {
-                return Err(OrchestrationError::Agent(
-                    "browser_open requires 'url'".into(),
-                ));
-            };
-            if crate::is_browser_running(config).await {
-                let result = crate::browser::navigate(config, url)
-                    .await
-                    .map_err(OrchestrationError::Agent)?;
-                Ok(result)
-            } else {
-                let opened = if cfg!(target_os = "macos") {
-                    std::process::Command::new("open").arg(url).spawn().is_ok()
-                } else if cfg!(target_os = "windows") {
-                    std::process::Command::new("cmd")
-                        .args(["/C", "start", url])
-                        .spawn()
-                        .is_ok()
-                } else {
-                    std::process::Command::new("xdg-open")
-                        .arg(url)
-                        .spawn()
-                        .is_ok()
-                };
-                if opened {
-                    Ok(format!(
-                        "Mint Auto is not active. Opened {url} in your default browser instead."
-                    ))
-                } else {
-                    Err(OrchestrationError::Agent(
-                        "Failed to open URL in default browser.".into(),
-                    ))
-                }
-            }
-        }
-        "browser_click" => {
-            let selector = if !input.selector.is_empty() {
-                &input.selector
-            } else if !input.path.is_empty() {
-                &input.path
-            } else {
-                return Err(OrchestrationError::Agent(
-                    "browser_click requires 'selector'".into(),
-                ));
-            };
-            let result = crate::browser::click(config, selector)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(result)
-        }
-        "browser_type" => {
-            let selector = if !input.selector.is_empty() {
-                &input.selector
-            } else if !input.path.is_empty() {
-                &input.path
-            } else {
-                return Err(OrchestrationError::Agent(
-                    "browser_type requires 'selector'".into(),
-                ));
-            };
-            let text = if !input.text.is_empty() {
-                &input.text
-            } else if !input.query.is_empty() {
-                &input.query
-            } else {
-                return Err(OrchestrationError::Agent(
-                    "browser_type requires 'text'".into(),
-                ));
-            };
-            let result = crate::browser::type_text(config, selector, text)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(result)
-        }
-        "browser_read" => {
-            let result = crate::browser::read_page_text(config)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(result)
-        }
-        "browser_mouse_move" => {
-            let x = input.x.ok_or_else(|| {
-                OrchestrationError::Agent("browser_mouse_move requires 'x'".into())
-            })?;
-            let y = input.y.ok_or_else(|| {
-                OrchestrationError::Agent("browser_mouse_move requires 'y'".into())
-            })?;
-            let result = crate::browser::mouse_move(config, x, y)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(result)
-        }
-        "browser_mouse_click" => {
-            let x = input.x.ok_or_else(|| {
-                OrchestrationError::Agent("browser_mouse_click requires 'x'".into())
-            })?;
-            let y = input.y.ok_or_else(|| {
-                OrchestrationError::Agent("browser_mouse_click requires 'y'".into())
-            })?;
-            let button = if input.button.is_empty() {
-                "left"
-            } else {
-                &input.button
-            };
-            let result = crate::browser::mouse_click(config, x, y, button)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(result)
-        }
-        "browser_key_press" => {
-            let key = if !input.key.is_empty() {
-                &input.key
-            } else {
-                return Err(OrchestrationError::Agent(
-                    "browser_key_press requires 'key'".into(),
-                ));
-            };
-            let result = crate::browser::key_press(config, key)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(result)
-        }
-        "browser_screenshot" => {
-            let data = crate::browser::screenshot(config)
-                .await
-                .map_err(OrchestrationError::Agent)?;
-            Ok(format!("data:image/png;base64,{data}"))
-        }
-        _ => unreachable!(
-            "execute_tool routed an unhandled action into tools::browser::execute: {action}"
-        ),
+    let mut args =
+        serde_json::to_value(input).map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+    // Preserve the established legacy argument aliases.
+    if input.url.is_empty() && !input.path.is_empty() {
+        args["url"] = input.path.clone().into();
     }
+    if input.selector.is_empty() && input.element_ref.is_empty() && !input.path.is_empty() {
+        args["selector"] = input.path.clone().into();
+    }
+    if input.text.is_empty() && !input.query.is_empty() {
+        args["text"] = input.query.clone().into();
+    }
+    crate::browser::execute_action(config, action, &args)
+        .await
+        .map_err(OrchestrationError::Agent)
 }

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

@@ -2,6 +2,11 @@ use std::path::Path;
 
 use super::super::*;
 
+fn is_skill_edit(root: &Path, path: &Path) -> Result<bool, OrchestrationError> {
+    crate::skills::skill_edit_requires_approval(root, path)
+        .map_err(|error| OrchestrationError::Agent(error.to_string()))
+}
+
 /// Handles the subset of `execute_tool` actions related to files.
 /// Only called for actions `execute_tool` has already routed here, so the
 /// fallback arm is unreachable in practice.
@@ -10,7 +15,7 @@ pub(in crate::orchestration) async fn execute(
     input: &AgentInput,
     root: &Path,
     config: &MintConfig,
-    _chat_id: &str,
+    chat_id: &str,
     approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
     match action {
@@ -21,7 +26,23 @@ pub(in crate::orchestration) async fn execute(
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?)
         }
         "read_file" => {
-            let path = workspace_path(root, required(&input.path, "path")?)?;
+            if input.start_line.is_none()
+                && input.end_line.is_none()
+                && let Some(skill) = crate::skills::skill_for_read_path(root, &input.path)
+            {
+                let memory = MemoryStore::open_default()?;
+                return crate::skills::read_skill_file(&memory, &skill, chat_id, config)
+                    .map_err(|error| OrchestrationError::Agent(error.to_string()));
+            }
+            // Explicit line-range reads are previews, never successful full skill loads.
+            // Known global skills may live outside the workspace, but still require
+            // the same path capability checks as any other file read.
+            let known_skill = crate::skills::skill_for_read_path(root, &input.path);
+            let path = if let Some(skill) = known_skill {
+                PathBuf::from(skill.source_path)
+            } else {
+                workspace_path(root, required(&input.path, "path")?)?
+            };
             let start = input.start_line.unwrap_or(1);
             let end = input.end_line.unwrap_or_else(|| start.saturating_add(239));
             Ok(read_code_file(&path, start, end, config)
@@ -86,12 +107,22 @@ pub(in crate::orchestration) async fn execute(
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            let approved = approve_cb(&AgentApproval::ApplyPatch {
-                path: patch.path.to_string_lossy().into_owned(),
-                hunks: patch.hunks.clone(),
-                diff,
-            })
-            .map_err(OrchestrationError::Agent)?;
+            let approval = if is_skill_edit(root, &proposal.edits[0].path)?
+                || is_skill_edit(root, &root.join(&patch.path))?
+            {
+                AgentApproval::SkillWrite {
+                    path: patch.path.to_string_lossy().into_owned(),
+                    content: edit.content.clone(),
+                    diff,
+                }
+            } else {
+                AgentApproval::ApplyPatch {
+                    path: patch.path.to_string_lossy().into_owned(),
+                    hunks: patch.hunks.clone(),
+                    diff,
+                }
+            };
+            let approved = approve_cb(&approval).map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -122,12 +153,22 @@ pub(in crate::orchestration) async fn execute(
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            let approved = approve_cb(&AgentApproval::WriteFile {
-                path: path_str.to_owned(),
-                content: input.file_content.clone(),
-                diff,
-            })
-            .map_err(OrchestrationError::Agent)?;
+            let approval = if is_skill_edit(root, &proposal.edits[0].path)?
+                || is_skill_edit(root, &root.join(path_str))?
+            {
+                AgentApproval::SkillWrite {
+                    path: path_str.to_owned(),
+                    content: edit.content.clone(),
+                    diff,
+                }
+            } else {
+                AgentApproval::WriteFile {
+                    path: path_str.to_owned(),
+                    content: input.file_content.clone(),
+                    diff,
+                }
+            };
+            let approved = approve_cb(&approval).map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -145,3 +186,109 @@ pub(in crate::orchestration) async fn execute(
         ),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn skill_writes_require_separate_approval_even_when_file_edits_are_allowed() {
+        let root =
+            std::env::temp_dir().join(format!("mint-skill-approval-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let config = MintConfig {
+            allowed_write_paths: vec![root.clone()],
+            allowed_read_paths: vec![root.clone()],
+            ..MintConfig::default()
+        };
+        let input = AgentInput {
+            path: ".agents/skills/example/SKILL.md".into(),
+            file_content: "---\ndescription: example\n---\nOriginal instructions".into(),
+            ..Default::default()
+        };
+        let mut requests = Vec::new();
+        let mut approve = |approval: &AgentApproval| {
+            let value = serde_json::to_value(approval).unwrap();
+            requests.push(value.clone());
+            Ok(if value.get("SkillWrite").is_some() {
+                ApprovalOutcome::Denied
+            } else {
+                ApprovalOutcome::Approved
+            })
+        };
+        execute(
+            "write_file",
+            &input,
+            &root,
+            &config,
+            "skill-test",
+            &mut approve,
+        )
+        .await
+        .unwrap();
+        assert!(
+            !root.join(&input.path).exists(),
+            "ordinary file approval must not authorize skill creation"
+        );
+        assert!(
+            requests[0]["SkillWrite"]["diff"]
+                .as_str()
+                .unwrap()
+                .contains("Original instructions")
+        );
+
+        let path = root.join(&input.path);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(&path, &input.file_content).unwrap();
+        let patch = AgentInput {
+            patch: Some(AgentPatch {
+                path: PathBuf::from(&input.path),
+                hunks: vec![CodePatchHunk {
+                    old_text: "Original instructions".into(),
+                    new_text: "Changed instructions".into(),
+                    replace_all: false,
+                }],
+            }),
+            ..Default::default()
+        };
+        execute(
+            "apply_patch",
+            &patch,
+            &root,
+            &config,
+            "skill-test",
+            &mut |approval| {
+                Ok(
+                    if serde_json::to_value(approval)
+                        .unwrap()
+                        .get("SkillWrite")
+                        .is_some()
+                    {
+                        ApprovalOutcome::Denied
+                    } else {
+                        ApprovalOutcome::Approved
+                    },
+                )
+            },
+        )
+        .await
+        .unwrap();
+        assert_eq!(std::fs::read_to_string(&path).unwrap(), input.file_content);
+        execute(
+            "apply_patch",
+            &patch,
+            &root,
+            &config,
+            "skill-test",
+            &mut |_| Ok(ApprovalOutcome::Approved),
+        )
+        .await
+        .unwrap();
+        assert!(
+            std::fs::read_to_string(&path)
+                .unwrap()
+                .contains("Changed instructions")
+        );
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}

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

@@ -10,7 +10,7 @@ pub(in crate::orchestration) async fn execute(
     input: &AgentInput,
     _root: &Path,
     config: &MintConfig,
-    _chat_id: &str,
+    chat_id: &str,
     _approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
     match action {
@@ -263,49 +263,34 @@ pub(in crate::orchestration) async fn execute(
                 num_images: Some(1),
                 ..Default::default()
             };
-            let res = crate::image_gen::generate_images(config, &req)
+            let res = crate::image_workflow::generate_and_save_images(config, &req)
                 .await
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
-            let data_uris: Vec<String> = res.images.iter().map(|i| i.data_uri.clone()).collect();
-            if let Ok(saved) = crate::pictures::save_chat_images(
-                data_uris,
-                Some(res.provider.clone()),
-                Some(prompt_text.to_string()),
-            ) {
-                if !saved.is_empty() {
-                    let saved_path = saved[0].path.display().to_string();
-                    let json_payload = serde_json::json!({
-                        "prompt": prompt_text,
-                        "model": res.model,
-                        "provider": res.provider,
-                        "images": saved.iter()
-                            .map(|s| serde_json::json!({ "url": format!("/api/pictures/{}", s.filename) }))
+            crate::library::LibraryStore::open_default()
+                .and_then(|store| {
+                    store.link_generated(
+                        &res.images
+                            .iter()
+                            .map(|image| image.id.clone())
                             .collect::<Vec<_>>(),
-                    });
-                    let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
-                    let data = format!(
-                        "Image generated successfully with model `{}` ({}). Saved to: {}\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
-                        res.model, res.provider, saved_path, json_str
-                    );
-                    return Ok(data);
-                }
-            }
-            if let Some(first) = res.images.first() {
-                let json_payload = serde_json::json!({
-                    "prompt": prompt_text,
-                    "model": res.model,
-                    "provider": res.provider,
-                    "images": [{ "url": first.data_uri }],
-                });
-                let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
-                let data = format!(
-                    "Image generated successfully with model `{}` ({}).\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
-                    res.model, res.provider, json_str
-                );
-                Ok(data)
-            } else {
-                Ok("No image returned from provider".to_string())
-            }
+                        chat_id,
+                    )
+                })
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            let saved_path = res.images[0].path.display().to_string();
+            let json_payload = serde_json::json!({
+                "prompt": res.prompt,
+                "model": res.model,
+                "provider": res.provider,
+                "images": res.images.iter()
+                    .map(|s| serde_json::json!({ "url": format!("/api/pictures/{}", s.filename) }))
+                    .collect::<Vec<_>>(),
+            });
+            let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
+            Ok(format!(
+                "Image generated successfully with model `{}` ({}). Saved to: {}\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
+                res.model, res.provider, saved_path, json_str
+            ))
         }
         "generate_video" | "veo.generate" | "video_generate" => {
             let prompt_text = if !input.prompt.trim().is_empty() {
@@ -334,6 +319,17 @@ pub(in crate::orchestration) async fn execute(
             let res = crate::video_gen::generate_video(config, &req)
                 .await
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            crate::library::LibraryStore::open_default()
+                .and_then(|store| {
+                    store.link_generated(
+                        &res.videos
+                            .iter()
+                            .map(|video| video.id.clone())
+                            .collect::<Vec<_>>(),
+                        chat_id,
+                    )
+                })
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
             if let Some(first) = res.videos.first() {
                 let vid_md = format!(
                     "<video controls src=\"{}\" width=\"100%\" style=\"max-height:400px; border-radius:8px;\"></video>\n\n✓ Video generated successfully with Veo `{}` ({})",

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

@@ -74,7 +74,8 @@ pub(in crate::orchestration) async fn execute(
             let mut results = Vec::new();
 
             if let Ok(memory) = MemoryStore::open_default() {
-                if let Ok(interactions) = memory.recent_interactions_for_chat(chat_id, 50) {
+                if let Ok(interactions) = memory.recent_completed_interactions_for_chat(chat_id, 50)
+                {
                     for item in interactions.iter().rev() {
                         if item.user_text.to_ascii_lowercase().contains(&query_lower)
                             || item.ai_text.to_ascii_lowercase().contains(&query_lower)
@@ -101,9 +102,10 @@ pub(in crate::orchestration) async fn execute(
                             || skill.name.to_ascii_lowercase().contains(&query_lower)
                         {
                             results.push(format!(
-                                "[Skill: {}]\n{}",
+                                "[Skill: {}]\nDescription: {}\nPath: {}\nRead through read_file before using this skill.",
                                 skill.name,
-                                truncate_for_context(&skill.content, 300)
+                                skill.description.as_deref().unwrap_or("No description provided"),
+                                skill.source_path
                             ));
                         }
                     }

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

@@ -10,3 +10,5 @@ pub(super) mod plugins_mcp;
 pub(super) mod project;
 pub(super) mod shell;
 pub(super) mod web;
+
+pub(super) mod mods;

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

@@ -0,0 +1,161 @@
+use super::super::*;
+
+pub(in crate::orchestration) async fn execute(
+    action: &str,
+    input: &AgentInput,
+    root: &Path,
+    config: &MintConfig,
+    chat: &str,
+    approve: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
+) -> Result<String, OrchestrationError> {
+    let result: Result<String, String> = (|| {
+        if action == "mod_help" {
+            return Ok(include_str!("../../../../../docs/mods/AUTHORING.md").into());
+        }
+        if action == "mod_list" {
+            return Ok(serde_json::json!({"mods":crate::mods::list(root,chat)?}).to_string());
+        }
+        let source: crate::mods::Source =
+            serde_json::from_value(input.arguments.clone()).map_err(|e| e.to_string())?;
+        let draft = crate::mods::save_draft(root, &source)?;
+        let preview = crate::mods::validate(root, &source)
+            .map_err(|error| format!("{error}\nDraft saved at {}", draft.display()))?;
+        if action == "mod_validate" {
+            return Ok(serde_json::json!({"valid":true,"preview":preview}).to_string());
+        }
+        crate::assert_path_capability(
+            &crate::mods::source_path(root, &source.manifest.id)?,
+            crate::Capability::Write,
+            config,
+        )
+        .map_err(|e| e.to_string())?;
+        let expected = input.arguments["expectedHash"].as_str();
+        let hash = crate::mods::publish(root, &source, expected)?;
+        let granted = if source.manifest.permissions.is_empty() {
+            false
+        } else {
+            let approval = AgentApproval::UserApproval {
+                title: format!("Enable {}", source.manifest.name),
+                prompt: format!(
+                    "Mod: {}\nRevision: {hash}\nPermissions: {}\n\n```typescript\n{}\n```",
+                    source.manifest.id,
+                    source.manifest.permissions.join(", "),
+                    source.source
+                ),
+            };
+            matches!(approve(&approval)?, ApprovalOutcome::Approved)
+        };
+        if source.manifest.permissions.is_empty() || granted {
+            crate::mods::enable_reviewed(
+                root,
+                chat,
+                &source.manifest.id,
+                "chat",
+                granted,
+                Some(&hash),
+            )?;
+        }
+        Ok(serde_json::json!({"path":crate::mods::source_path(root, &source.manifest.id)?,"hash":hash,"validated":true,"enabled":source.manifest.permissions.is_empty()||granted}).to_string())
+    })();
+    result.map_err(OrchestrationError::Agent)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test]
+    async fn mod_requests_respect_plan_mode_disabled_tools_and_deliver_results() {
+        let root = std::env::temp_dir().join(format!("mint-mod-policy-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let chat = uuid::Uuid::new_v4().to_string();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            allowed_write_paths: vec![root.clone()],
+            disabled_tools: vec!["read_file".into()],
+            ..Default::default()
+        };
+        let source: crate::mods::Source = serde_json::from_value(serde_json::json!({"manifest":{"id":"policy-test","name":"Policy test","version":"1","sdkVersion":1,"entry":"main.ts","permissions":["tools.request"]},"source":"export function register(mint){mint.on('session_start',()=>{mint.tools.request('write_file',{path:'should-not-exist',content:'bad'});mint.tools.request('read_file',{path:'README.md'});});mint.on('tool_result',r=>{if(!r.error)throw Error('Expected policy rejection');mint.state.set('results',(mint.state.get('results')||0)+1);});}"})).unwrap();
+        crate::mods::publish(&root, &source, None).unwrap();
+        crate::mods::enable(&root, &chat, "policy-test", "chat", true).unwrap();
+        crate::mods::set_turn_policy(&root, &chat, true, None);
+        execute_mod_requests(
+            &root,
+            &chat,
+            &config,
+            false,
+            &mut |_| panic!("Policy rejection must precede approvals"),
+            &mut |_| {},
+            None,
+        )
+        .await
+        .unwrap();
+        assert!(!root.join("should-not-exist").exists());
+        let mods = crate::mods::list(&root, &chat).unwrap();
+        assert_eq!(mods[0]["snapshot"]["state"]["results"], 2);
+        assert!(
+            crate::mods::pending_requests(&root, &chat)
+                .unwrap()
+                .is_empty()
+        );
+        crate::mods::close_chat(&root, &chat);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+    #[tokio::test]
+    async fn authoring_tools_preserve_failed_drafts_and_publish_a_live_mod() {
+        let root =
+            std::env::temp_dir().join(format!("mint-mod-authoring-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let chat = uuid::Uuid::new_v4().to_string();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            allowed_write_paths: vec![root.clone()],
+            ..Default::default()
+        };
+        let manifest = serde_json::json!({"id":"prompt-test","name":"Prompt test","version":"1","sdkVersion":1,"entry":"main.ts","permissions":[]});
+        let invalid: crate::mods::Source = serde_json::from_value(
+            serde_json::json!({"manifest":manifest,"source":"export ???","readme":"Draft"}),
+        )
+        .unwrap();
+        let saved = crate::mods::save_draft(&root, &invalid).unwrap();
+        let mut input = AgentInput::default();
+        input.arguments = serde_json::to_value(&invalid).unwrap();
+        let mut approve = |_: &AgentApproval| panic!("Basic mod requires no permission prompt");
+        assert!(
+            execute("mod_validate", &input, &root, &config, &chat, &mut approve)
+                .await
+                .is_err()
+        );
+        assert!(saved.is_file());
+        assert!(!root.join(".mint-mods/prompt-test").exists());
+        input.arguments["source"] = serde_json::json!(
+            "export async function register(mint){await Promise.resolve();mint.ui.set('above_composer',{type:'text',text:'Created from prompt'});}"
+        );
+        let validation = execute("mod_validate", &input, &root, &config, &chat, &mut approve)
+            .await
+            .unwrap();
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&validation).unwrap()["valid"],
+            true
+        );
+        let result = execute("mod_publish", &input, &root, &config, &chat, &mut approve)
+            .await
+            .unwrap();
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&result).unwrap()["enabled"],
+            true
+        );
+        let published: serde_json::Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(
+            published["path"],
+            serde_json::json!(root.join(".mint-mods/prompt-test"))
+        );
+        assert!(root.join(".mint-mods/prompt-test/main.ts").is_file());
+        let mods = crate::mods::list(&root, &chat).unwrap();
+        assert_eq!(
+            mods[0]["snapshot"]["ui"]["above_composer"]["text"],
+            "Created from prompt"
+        );
+        crate::mods::close_chat(&root, &chat);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}