Use map_err with miette! directly instead of map_err + wrap_err
chains. LuaError is not Send + Sync so it cannot use into_diagnostic;
the map_err pattern with an inline message is simpler anyway.

into_diagnostic remains only for fs-err errors (Send + Sync, and
fs-err already includes the path in its messages).

Assisted-by: Claude Opus 4.6 via pi

diff --git a/frork-cli/src/assertions.rs b/frork-cli/src/assertions.rs
index 5dfaa0c..1c4382c 100644
--- a/frork-cli/src/assertions.rs
+++ b/frork-cli/src/assertions.rs
@@ -1,5 +1,7 @@
 use fs_err as fs;
-use miette::{Result, miette};
+use miette::IntoDiagnostic as _;
+use miette::Result;
+use miette::miette;
 use mlua::prelude::*;
 use serde::Deserialize;
 use std::path::Path;
@@ -33,7 +35,7 @@ where
     fn create(&self, lua: &Lua, args: LuaMultiValue) -> Result<Box<dyn AssertionType>> {
         T::from_lua_multi(args, lua)
             .map(|t| Box::new(t) as Box<dyn AssertionType>)
-            .map_err(|e| miette!("Failed to create assertion type: {}", e))
+            .map_err(|e| miette!("Failed to create assertion type: {e}"))
     }
 }
 
@@ -178,7 +180,7 @@ impl AssertionType for Symlink {
     fn install(&self) -> Result<()> {
         use std::os::unix::fs;
         fs::symlink(&self.source, &self.target)
-            .map_err(|e| miette!("Failed to create symlink: {}", e))?;
+            .map_err(|e| miette!("Failed to create symlink: {e}"))?;
         debug!("created: {}", self);
         Ok(())
     }
@@ -225,7 +227,7 @@ impl AssertionType for Directory {
     }
 
     fn install(&self) -> Result<()> {
-        fs::create_dir_all(&self.path).map_err(|e| miette!("Failed to create directory: {}", e))?;
+        fs::create_dir_all(&self.path).into_diagnostic()?;
         debug!("created: {}", self);
         Ok(())
     }
@@ -267,7 +269,7 @@ impl AssertionType for Debug {
         if let Some(ref status_fn) = self.status_fn {
             let result = status_fn
                 .call::<Status>(LuaMultiValue::new())
-                .map_err(|e| miette!("Debug status function failed: {}", e))?;
+                .map_err(|e| miette!("Debug status function failed: {e}"))?;
             Ok(result)
         } else {
             Ok(Status::Ok)
@@ -282,7 +284,7 @@ impl AssertionType for Debug {
             .ok_or_else(|| miette!("Install not implemented for debug assertion"))?;
         install_fn
             .call::<()>(LuaMultiValue::new())
-            .map_err(|e| miette!("Debug install function failed: {}", e))?;
+            .map_err(|e| miette!("Debug install function failed: {e}"))?;
         Ok(())
     }
 
@@ -334,8 +336,7 @@ impl AssertionType for Git {
         }
 
         // Check if directory is empty (only . and ..)
-        let mut entries =
-            fs::read_dir(dir_path).map_err(|e| miette!("Failed to read directory: {}", e))?;
+        let mut entries = fs::read_dir(dir_path).into_diagnostic()?;
         if entries.next().is_none() {
             return Ok(Status::Missing);
         }
diff --git a/frork-cli/src/main.rs b/frork-cli/src/main.rs
index 6a22411..6b14008 100644
--- a/frork-cli/src/main.rs
+++ b/frork-cli/src/main.rs
@@ -188,19 +188,19 @@ fn setup_lua(
     let fennel_module: LuaTable = lua
         .load(fennel_code)
         .eval()
-        .map_err(|e| miette!("Failed to load Fennel: {}", e))?;
+        .map_err(|e| miette!("Failed to load Fennel: {e}"))?;
     lua.register_module("fennel", &fennel_module)
-        .map_err(|e| miette!("Failed to register fennel module: {}", e))?;
+        .map_err(|e| miette!("Failed to register fennel module: {e}"))?;
 
     let frork_table = match Frork::new(handle_status, lua.clone())
         .into_lua(&lua)
-        .map_err(|e| miette!("Failed to create frork table: {}", e))?
+        .map_err(|e| miette!("Failed to create frork table: {e}"))?
     {
         LuaValue::Table(table) => table,
         _ => unreachable!(),
     };
     lua.register_module("frork", &frork_table)
-        .map_err(|e| miette!("Failed to register frork module: {}", e))?;
+        .map_err(|e| miette!("Failed to register frork module: {e}"))?;
 
     Ok((lua, frork_table, fennel_module))
 }
@@ -213,18 +213,18 @@ fn run_code(
 
     let ok_fn: LuaFunction = frork_module
         .get("ok")
-        .map_err(|e| miette!("Failed to get frork.ok: {}", e))?;
+        .map_err(|e| miette!("Failed to get frork.ok: {e}"))?;
     lua.globals()
         .set("ok", ok_fn)
-        .map_err(|e| miette!("Failed to set ok global: {}", e))?;
+        .map_err(|e| miette!("Failed to set ok global: {e}"))?;
 
     let eval_fn: LuaFunction = fennel_module
         .get("eval")
-        .map_err(|e| miette!("Failed to get fennel.eval: {}", e))?;
+        .map_err(|e| miette!("Failed to get fennel.eval: {e}"))?;
 
     eval_fn
         .call::<()>(code)
-        .map_err(|e| miette!("Failed to execute fennel code: {}", e))?;
+        .map_err(|e| miette!("Failed to execute fennel code: {e}"))?;
 
     Ok(())
 }
@@ -243,19 +243,19 @@ fn run_script(
         let package_table: LuaTable = lua
             .globals()
             .get("package")
-            .map_err(|e| miette!("Failed to get package table: {}", e))?;
+            .map_err(|e| miette!("Failed to get package table: {e}"))?;
 
         // Add to Lua search path
         let current_path: String = package_table
             .get("path")
-            .map_err(|e| miette!("Failed to get current Lua path: {}", e))?;
+            .map_err(|e| miette!("Failed to get current Lua path: {e}"))?;
         let new_path = format!(
             "{};{}/?.lua;{}/?/init.lua",
             current_path, script_dir_str, script_dir_str
         );
         package_table
             .set("path", new_path)
-            .map_err(|e| miette!("Failed to set Lua path: {}", e))?;
+            .map_err(|e| miette!("Failed to set Lua path: {e}"))?;
 
         // Add to Fennel search path
         let current_fennel_path: String = fennel_module
@@ -267,7 +267,7 @@ fn run_script(
         );
         fennel_module
             .set("path", new_fennel_path)
-            .map_err(|e| miette!("Failed to set Fennel path: {}", e))?;
+            .map_err(|e| miette!("Failed to set Fennel path: {e}"))?;
     }
 
     lua.load(format!(
@@ -275,7 +275,7 @@ fn run_script(
         script
     ))
     .exec()
-    .map_err(|e| miette!("Failed to execute script: {}", e))?;
+    .map_err(|e| miette!("Failed to execute script: {e}"))?;
 
     Ok(())
 }
@@ -311,12 +311,12 @@ fn satisfy(status: &Status, assertion: &dyn AssertionType) -> Result<()> {
             print!("Upgrade? [y/N]: ");
             std::io::stdout()
                 .flush()
-                .map_err(|e| miette!("Failed to flush stdout: {}", e))?;
+                .map_err(|e| miette!("Failed to flush stdout: {e}"))?;
 
             let mut input = String::new();
             std::io::stdin()
                 .read_line(&mut input)
-                .map_err(|e| miette!("Failed to read input: {}", e))?;
+                .map_err(|e| miette!("Failed to read input: {e}"))?;
 
             match input.trim().to_lowercase().as_str() {
                 "y" | "yes" => {
diff --git a/frork-cli/src/utils.rs b/frork-cli/src/utils.rs
index 282aefe..2d88a38 100644
--- a/frork-cli/src/utils.rs
+++ b/frork-cli/src/utils.rs
@@ -1,4 +1,5 @@
-use miette::{Result, miette};
+use miette::Result;
+use miette::miette;
 use mlua::prelude::*;
 use regex::Regex;
 use std::env;
@@ -168,7 +169,7 @@ impl Utils {
 
         let output = command
             .output()
-            .map_err(|e| miette!("Failed to execute command '{}': {}", cmd, e))?;
+            .map_err(|e| miette!("Failed to execute command '{}': {e}", cmd))?;
 
         let stdout = String::from_utf8_lossy(&output.stdout).to_string();
         let status = output