refactor!: replace pack! macros with derive-based pipeline types

Remove the `pack!`, `pack_err!`, `pack_structural!`, and
`pack_err_structural!` macros, replacing all pipeline type definitions
with `#[derive(Grouped)]` and `#[derive(Grouped, Wrap)]` attributes.
This changes the generated struct shape from named-field structs with an
`inner` field to tuple structs accessed via `.0`, and removes the
auto-generated `name` and `info` fields from error types.

15 files changed, 247 insertions, 191 deletions

diff --git a/mingling_cli/src/config/cmd_cfg.rs b/mingling_cli/src/config/cmd_cfg.rs
index c10195e..8baa4a1 100644
--- a/mingling_cli/src/config/cmd_cfg.rs
+++ b/mingling_cli/src/config/cmd_cfg.rs
@@ -1,8 +1,6 @@
 use mingling::{
-    LazyRes, Routable, ShellContext, Suggest,
-    macros::{
-        arg, buffer, chain, command, completion, metadata, pack, r_println, renderer, suggest,
-    },
+    Grouped, LazyRes, Routable, ShellContext, Suggest, Wrap,
+    macros::{arg, buffer, chain, command, completion, metadata, r_println, renderer, suggest},
     metadata::Description,
     picker::{EntryPicker, PickerArg, value::Flag},
 };
@@ -11,10 +9,17 @@ use crate::{Entry, Next, config::ResMlingConfig};
 
 const FLAG_PAIR: PickerArg<Flag> = arg![pair: Flag];
 
-pack!(StateConfigEdit = (String, String));
-pack!(ResultConfigKeyValuePair = String);
-pack!(ResultConfigValue = String);
-pack!(ResultConfig = ());
+#[derive(Grouped, Wrap)]
+pub struct StateConfigEdit((String, String));
+
+#[derive(Grouped, Wrap)]
+pub struct ResultConfigKeyValuePair(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ResultConfigValue(String);
+
+#[derive(Grouped)]
+pub struct ResultConfig;
 
 #[command]
 pub fn cfg(args: Entry) -> Next {
@@ -27,19 +32,19 @@ pub fn cfg(args: Entry) -> Next {
     match (key, value) {
         (Some(k), Some(v)) => {
             // Edit
-            StateConfigEdit::new((k, v)).into()
+            StateConfigEdit((k, v)).into()
         }
         (Some(k), None) => {
             // Display
             if *show_pair {
-                ResultConfigKeyValuePair::new(k).to_render()
+                ResultConfigKeyValuePair(k).to_render()
             } else {
-                ResultConfigValue::new(k).to_render()
+                ResultConfigValue(k).to_render()
             }
         }
         (None, None) => {
             // List
-            ResultConfig::new(()).to_render()
+            ResultConfig.to_render()
         }
         _ => {
             unreachable!("This path is unreachable given the positional parsing done by arg-picker")
@@ -50,13 +55,13 @@ pub fn cfg(args: Entry) -> Next {
 #[chain]
 pub fn handle_state_config_edit(kv: StateConfigEdit, config: &mut LazyRes<ResMlingConfig>) {
     let config = config.get_mut();
-    config.edit(&kv.0, &kv.1);
+    config.edit(&kv.0.0, &kv.0.1);
 }
 
 #[renderer(buffer)]
 pub fn render_config_kvp(r: ResultConfigKeyValuePair, config: &mut LazyRes<ResMlingConfig>) {
     let config = config.get_ref();
-    let key = r.inner;
+    let key = r.0;
     let value = config.get(&key);
     r_println!(
         "\"{}\" = \"{}\"",
@@ -68,7 +73,7 @@ pub fn render_config_kvp(r: ResultConfigKeyValuePair, config: &mut LazyRes<ResMl
 #[renderer(buffer)]
 pub fn render_config_value(r: ResultConfigValue, config: &mut LazyRes<ResMlingConfig>) {
     let config = config.get_ref();
-    let key = r.inner;
+    let key = r.0;
     let value = config.get(&key);
     r_println!("{}", value)
 }
diff --git a/mingling_cli/src/lib.rs b/mingling_cli/src/lib.rs
index 902ab32..e82300e 100644
--- a/mingling_cli/src/lib.rs
+++ b/mingling_cli/src/lib.rs
@@ -45,7 +45,7 @@ pub fn complete_global(_ctx: &ShellContext) -> Suggest {
 #[renderer]
 pub fn handle_fallback(args: EntryFallback) -> RenderResult {
     let mut r = RenderResult::new();
-    let args = args.inner;
+    let args = args.0;
     if !args.is_empty() {
         eprintln_cargo!(
             r,
diff --git a/mingling_cli/src/linter/cmd_explain.rs b/mingling_cli/src/linter/cmd_explain.rs
index 5346255..923e890 100644
--- a/mingling_cli/src/linter/cmd_explain.rs
+++ b/mingling_cli/src/linter/cmd_explain.rs
@@ -1,10 +1,7 @@
 use crate::{Next, eprintln_cargo, linter::registry::ResLintRegistry};
 use mingling::{
-    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{
-        arg, buffer, chain, completion, dispatcher, metadata, pack, pack_err, r_println, renderer,
-        routeify,
-    },
+    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, buffer, chain, completion, dispatcher, metadata, r_println, renderer, routeify},
     metadata::Description,
     picker::EntryPicker,
 };
@@ -16,9 +13,14 @@ pub fn desc_explain() -> Description {
     "Explain the meaning of the specified Lint".into()
 }
 
-pack!(StateExplainLint = String);
-pack_err!(ErrorNoExplainLintProvided);
-pack_err!(ErrorNoSuchLint = String);
+#[derive(Grouped, Wrap)]
+pub struct StateExplainLint(String);
+
+#[derive(Grouped, Default)]
+pub struct ErrorNoExplainLintProvided;
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorNoSuchLint(String);
 
 #[derive(Debug, Default, Grouped)]
 pub struct ResultExplainLint {
@@ -33,11 +35,9 @@ pub struct ResultExplainLint {
 #[chain(routeify)]
 pub fn handle_explain(args: EntryExplain) -> Next {
     let lint_name = args
-        .pick_or_route(&arg![String], || {
-            ErrorNoExplainLintProvided::default().to_chain()
-        })
+        .pick_or_route(&arg![String], || ErrorNoExplainLintProvided.to_chain())
         .to_result()?;
-    StateExplainLint::new(lint_name).into()
+    StateExplainLint(lint_name).into()
 }
 
 #[chain]
@@ -46,9 +46,9 @@ pub fn handle_state_explain_lint(
     registry: &mut LazyRes<ResLintRegistry>,
 ) -> Next {
     let registry = registry.get_ref();
-    let lint_name = p.inner;
+    let lint_name = p.0;
     let Some(entry) = registry.lints.iter().find(|l| l.name == lint_name) else {
-        return ErrorNoSuchLint::new(lint_name).to_chain();
+        return ErrorNoSuchLint(lint_name).to_chain();
     };
     ResultExplainLint {
         lint_name: entry.name.clone(),
@@ -87,7 +87,7 @@ pub fn render_error_no_such_lint(
 ) -> RenderResult {
     let mut r = RenderResult::new();
     let registry = registry.get_ref();
-    eprintln_cargo!(r, "No such lint: \"{}\"", err.info);
+    eprintln_cargo!(r, "No such lint: \"{}\"", err.0);
     r_println!(r, "");
     r_println!(r, "Available lints:");
     for entry in registry.lints.iter() {
diff --git a/mingling_cli/src/linter/cmd_lint.rs b/mingling_cli/src/linter/cmd_lint.rs
index 07c18c5..7cab63a 100644
--- a/mingling_cli/src/linter/cmd_lint.rs
+++ b/mingling_cli/src/linter/cmd_lint.rs
@@ -1,10 +1,11 @@
 use crate::linter::mlint_report::{MlintReport, StateLintReports};
 use cargo_metadata::Metadata;
 use mingling::consts::REMAINS;
-use mingling::macros::{arg, chain, completion, dispatcher, metadata, pack, suggest};
+use mingling::macros::{arg, chain, completion, dispatcher, metadata, suggest};
 use mingling::metadata::Description;
 use mingling::picker::parselib::ParserStyle;
 use mingling::picker::{EntryPicker, PickerArg};
+use mingling::{Grouped, Wrap};
 use mingling::{LazyRes, ShellContext, Suggest};
 use tokio::task::JoinSet;
 
@@ -77,7 +78,8 @@ async fn linter_main(metadata: &Metadata) -> Vec<MlintReport> {
     all_reports
 }
 
-pack!(StateBeginLinter = ());
+#[derive(Grouped, Wrap)]
+pub struct StateBeginLinter(());
 
 #[chain]
 pub fn handle_lint(args: EntryLint) -> StateBeginLinter {
@@ -88,7 +90,7 @@ pub fn handle_lint(args: EntryLint) -> StateBeginLinter {
 
     // If with_checker is not set, proceed directly to the mingling lint phase
     let Some(with_checker) = with_checker else {
-        return StateBeginLinter::new(());
+        return StateBeginLinter(());
     };
 
     let with_checker: Vec<&str> = with_checker.split(',').collect();
@@ -97,7 +99,7 @@ pub fn handle_lint(args: EntryLint) -> StateBeginLinter {
     // Run the outer checker (e.g. cargo check) with output passed through directly
     execute_checker(&with_checker, checker_args.as_slice());
 
-    StateBeginLinter::new(())
+    StateBeginLinter(())
 }
 
 /// Run the outer checker (e.g. cargo check) with output passed through directly.
@@ -135,7 +137,7 @@ pub async fn handle_state_begin_linter(
 ) -> StateLintReports {
     let metadata = metadata.get_ref().data();
     let reports = linter_main(metadata).await;
-    StateLintReports::new(reports)
+    StateLintReports(reports)
 }
 
 #[completion(EntryLint)]
diff --git a/mingling_cli/src/linter/mlint_report.rs b/mingling_cli/src/linter/mlint_report.rs
index b594b9d..d7bf652 100644
--- a/mingling_cli/src/linter/mlint_report.rs
+++ b/mingling_cli/src/linter/mlint_report.rs
@@ -9,8 +9,8 @@ use cargo_metadata::{Message, PackageId};
 
 use annotate_snippets::level::{ERROR, HELP, NOTE, WARNING};
 use annotate_snippets::{AnnotationKind, Group, Patch, Renderer, Snippet};
-use mingling::macros::{buffer, chain, pack, r_append, r_eprintln, renderer};
-use mingling::{RendererInvoker, Routable};
+use mingling::macros::{buffer, chain, r_append, r_eprintln, renderer};
+use mingling::{Grouped, RendererInvoker, Routable, Wrap};
 
 use crate::Next;
 use crate::metadata::setup::ResUsingJson;
@@ -416,22 +416,25 @@ impl MlintReport {
     }
 }
 
-pack!(StateLintReports = Vec<MlintReport>);
-pack!(ResultLintReportsAnnotateSnippet = Vec<MlintReport>);
-pack!(ResultLintReportsJson = Vec<MlintReport>);
+#[derive(Grouped, Wrap)]
+pub struct StateLintReports(pub Vec<MlintReport>);
+#[derive(Grouped, Wrap)]
+pub struct ResultLintReportsAnnotateSnippet(Vec<MlintReport>);
+#[derive(Grouped, Wrap)]
+pub struct ResultLintReportsJson(Vec<MlintReport>);
 
 #[chain]
 pub fn handle_state_lint_reports(reports: StateLintReports, using_json: &ResUsingJson) -> Next {
     if using_json.using {
-        ResultLintReportsJson::new(reports.inner).to_render()
+        ResultLintReportsJson(reports.0).to_render()
     } else {
-        ResultLintReportsAnnotateSnippet::new(reports.inner).to_render()
+        ResultLintReportsAnnotateSnippet(reports.0).to_render()
     }
 }
 
 #[renderer(buffer)]
 pub fn render_lint_reports(reports: ResultLintReportsAnnotateSnippet) {
-    for report in reports.inner {
+    for report in reports.0 {
         r_eprintln!("{}", report.to_annotate_snippet_render());
     }
 }
@@ -441,7 +444,7 @@ pub fn render_lint_reports_json(
     reports: ResultLintReportsJson,
     message_renderer: &RendererInvoker<Message>,
 ) {
-    for report in reports.inner {
+    for report in reports.0 {
         let message = report.to_compiler_message();
         let result = message_renderer.invoke(message);
         r_append!(result);
diff --git a/mingling_cli/src/metadata/cmd_metadata.rs b/mingling_cli/src/metadata/cmd_metadata.rs
index 3ee9f09..7f8d4ad 100644
--- a/mingling_cli/src/metadata/cmd_metadata.rs
+++ b/mingling_cli/src/metadata/cmd_metadata.rs
@@ -1,7 +1,7 @@
 use cargo_metadata::Metadata;
 use mingling::{
-    LazyRes,
-    macros::{chain, dispatcher, metadata, pack},
+    Grouped, LazyRes, Wrap,
+    macros::{chain, dispatcher, metadata},
     metadata::Description,
 };
 
@@ -16,7 +16,8 @@ pub fn desc_metadata() -> Description {
         .into()
 }
 
-pack!(ResultMetadata = ResMetadata);
+#[derive(Grouped, Wrap)]
+pub struct ResultMetadata(ResMetadata);
 
 #[chain]
 pub fn handle_metadata(_: EntryMetadata, metadata: &mut LazyRes<ResMetadata>) -> Metadata {
diff --git a/mingling_cli/src/pkg_mgr.rs b/mingling_cli/src/pkg_mgr.rs
index e140991..8493804 100644
--- a/mingling_cli/src/pkg_mgr.rs
+++ b/mingling_cli/src/pkg_mgr.rs
@@ -8,16 +8,23 @@ pub mod cmd_uninstall;
 use std::path::PathBuf;
 
 use mingling::{
-    Program, RenderResult,
-    macros::{pack_err, program_setup, r_println, renderer},
+    Grouped, Program, RenderResult, Wrap,
+    macros::{program_setup, r_println, renderer},
 };
 
 use crate::{ThisProgram, eprintln_cargo, hprintln_cargo};
 
-pack_err!(ErrorRootPackageNotFound);
-pack_err!(ErrorNoDataDirectory);
-pack_err!(ErrorPackageSpecInvalid = String);
-pack_err!(ErrorPackageNameRequired);
+#[derive(Grouped, Default)]
+pub struct ErrorRootPackageNotFound;
+
+#[derive(Grouped, Default)]
+pub struct ErrorNoDataDirectory;
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorPackageSpecInvalid(String);
+
+#[derive(Grouped, Default)]
+pub struct ErrorPackageNameRequired;
 
 /// The `mingling/packages` packages directory under the user's data directory.
 #[derive(Debug, Default, Clone)]
@@ -55,7 +62,7 @@ pub fn render_error_no_data_directory(_: ErrorNoDataDirectory) -> RenderResult {
 #[renderer]
 pub fn render_error_package_spec_invalid(err: ErrorPackageSpecInvalid) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "invalid package spec: {}", err.info);
+    eprintln_cargo!(r, "invalid package spec: {}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_install.rs b/mingling_cli/src/pkg_mgr/cmd_install.rs
index 731ba98..8b2f3b7 100644
--- a/mingling_cli/src/pkg_mgr/cmd_install.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_install.rs
@@ -2,8 +2,8 @@ use std::{env, fs, io, path::PathBuf, process::Command};
 
 use cargo_metadata::TargetKind;
 use mingling::{
-    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest,
-    macros::{arg, chain, command, completion, metadata, pack_err, renderer, routeify, suggest},
+    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify, suggest},
     metadata::Description,
     picker::{EntryPicker, PickerArg, value::Flag},
 };
@@ -15,9 +15,14 @@ use crate::{
     println_cargo,
 };
 
-pack_err!(ErrorBuildFailed = String);
-pack_err!(ErrorBinaryNotFound = String);
-pack_err!(ErrorPkgEnableFailed = String);
+#[derive(Grouped, Wrap)]
+pub struct ErrorBuildFailed(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorBinaryNotFound(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorPkgEnableFailed(String);
 
 /// Flag: `--enable` — run `mling pkg-enable` after a successful install
 /// to enable the package being installed.
@@ -75,13 +80,13 @@ pub fn install(
     let metadata = metadata.get_ref().data();
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let root_package = metadata
         .root_package()
         .or_else(|| metadata.workspace_packages().first().copied())
-        .ok_or(ErrorRootPackageNotFound::default())?;
+        .ok_or(ErrorRootPackageNotFound)?;
 
     StateInstallBuild {
         workspace_root: metadata.workspace_root.clone().into_std_path_buf(),
@@ -103,11 +108,9 @@ pub fn handle_state_install_build(state: StateInstallBuild) -> Next {
         .args(["build", "--release"])
         .current_dir(&state.workspace_root)
         .status()
-        .map_err(|e| {
-            ErrorBuildFailed::new(format!("failed to run `cargo build --release`: {e}"))
-        })?;
+        .map_err(|e| ErrorBuildFailed(format!("failed to run `cargo build --release`: {e}")))?;
     if !status.success() {
-        return ErrorBuildFailed::new(format!("`cargo build --release` failed with {status}"))
+        return ErrorBuildFailed(format!("`cargo build --release` failed with {status}"))
             .to_chain();
     }
 
@@ -146,7 +149,7 @@ pub fn handle_state_install_copy(
             let bin_file = format!("{}{}", target.name, state.exe_suffix);
             let src = state.release_dir.join(&bin_file);
             if !src.is_file() {
-                return ErrorBinaryNotFound::new(bin_file).to_chain();
+                return ErrorBinaryNotFound(bin_file).to_chain();
             }
             let dst = state.install_dir.join(&bin_file);
             fs::copy(&src, &dst).map_err(|e| {
@@ -181,7 +184,7 @@ pub fn handle_state_install_copy(
         let root_package = metadata
             .root_package()
             .or_else(|| metadata.workspace_packages().first().copied())
-            .ok_or(ErrorRootPackageNotFound::default())?;
+            .ok_or(ErrorRootPackageNotFound)?;
         return StateInstallEnable {
             install_dir: state.install_dir,
             installed: state.installed,
@@ -207,13 +210,11 @@ pub fn handle_state_install_enable(state: StateInstallEnable) -> Next {
         .args(["pkg-enable", &spec])
         .status()
         .map_err(|e| {
-            ErrorPkgEnableFailed::new(format!("failed to run `mling pkg-enable {spec}`: {e}"))
+            ErrorPkgEnableFailed(format!("failed to run `mling pkg-enable {spec}`: {e}"))
         })?;
     if !status.success() {
-        return ErrorPkgEnableFailed::new(format!(
-            "`mling pkg-enable {spec}` failed with {status}"
-        ))
-        .to_chain();
+        return ErrorPkgEnableFailed(format!("`mling pkg-enable {spec}` failed with {status}"))
+            .to_chain();
     }
 
     ResultInstall {
@@ -236,21 +237,21 @@ pub fn render_result_install(result: ResultInstall) -> RenderResult {
 #[renderer]
 pub fn render_error_build_failed(err: ErrorBuildFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_binary_not_found(err: ErrorBinaryNotFound) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "binary not found: {}", err.info);
+    eprintln_cargo!(r, "binary not found: {}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_pkg_enable_failed(err: ErrorPkgEnableFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs b/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
index b4928ce..f0ac88a 100644
--- a/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
@@ -4,8 +4,8 @@ use std::{
 };
 
 use mingling::{
-    Routable,
-    macros::{buffer, command, pack, r_println, renderer, routeify},
+    Grouped, Routable, Wrap,
+    macros::{buffer, command, r_println, renderer, routeify},
 };
 
 use crate::{
@@ -14,16 +14,18 @@ use crate::{
 };
 
 // Version directory paths of every enabled package.
-pack!(ResultLoadPkgsPaths = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ResultLoadPkgsPaths(Vec<PathBuf>);
 
 // Completion script paths of every enabled package.
-pack!(ResultLoadPkgsComps = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ResultLoadPkgsComps(Vec<PathBuf>);
 
 #[command(node = "__loadpkgs_path", routeify)]
 pub fn load_packages_paths(packages_dir: &ResPackagesDir) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     let paths = enabled_version_dirs(packages_dir).map_err(|e| {
         io::Error::new(
@@ -31,14 +33,14 @@ pub fn load_packages_paths(packages_dir: &ResPackagesDir) -> Next {
             format!("failed to read {}: {e}", packages_dir.display()),
         )
     })?;
-    ResultLoadPkgsPaths::new(paths).to_chain()
+    ResultLoadPkgsPaths(paths).to_chain()
 }
 
 #[command(node = "__loadpkgs_comp_scripts", routeify)]
 pub fn load_packages_comp_scripts(packages_dir: &ResPackagesDir) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     let scripts = comp_scripts(packages_dir).map_err(|e| {
         io::Error::new(
@@ -46,19 +48,19 @@ pub fn load_packages_comp_scripts(packages_dir: &ResPackagesDir) -> Next {
             format!("failed to read {}: {e}", packages_dir.display()),
         )
     })?;
-    ResultLoadPkgsComps::new(scripts).to_chain()
+    ResultLoadPkgsComps(scripts).to_chain()
 }
 
 #[renderer(buffer)]
 pub fn render_result_load_pkgs_paths(r: ResultLoadPkgsPaths) {
-    for path in r.inner {
+    for path in r.0 {
         r_println!("{}", path.display());
     }
 }
 
 #[renderer(buffer)]
 pub fn render_result_load_pkgs_comps(r: ResultLoadPkgsComps) {
-    for path in r.inner {
+    for path in r.0 {
         r_println!("{}", path.display());
     }
 }
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
index 041bb09..b4989eb 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
@@ -1,8 +1,8 @@
 use std::{fs, io};
 
 use mingling::{
-    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
@@ -18,10 +18,12 @@ use crate::{
 /// Positional argument: package name
 pub static ARG_NAME: PickerArg<String> = arg![String];
 
-pack_err!(ErrorPackageNotEnabled = String);
+#[derive(Grouped, Wrap)]
+pub struct ErrorPackageNotEnabled(String);
 
 // The name of the package to disable
-pack!(StatePkgDisable = String);
+#[derive(Grouped, Wrap)]
+pub struct StatePkgDisable(String);
 
 #[derive(Debug, Default, Grouped)]
 pub struct ResultPkgDisable {
@@ -37,30 +39,30 @@ pub fn desc_pkg_disable() -> Description {
 #[command(node = "pkg-disable", routeify)]
 pub fn package_disable(args: EntryPkgDisable, packages_dir: &ResPackagesDir) -> Next {
     let name = args
-        .pick_or_route(&ARG_NAME, || ErrorPackageNameRequired::default().to_chain())
+        .pick_or_route(&ARG_NAME, || ErrorPackageNameRequired.to_chain())
         .to_result()?;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     if name.contains('/') || name.contains('\\') || name.contains("..") || name.contains('@') {
-        return ErrorPackageSpecInvalid::new(name).to_chain();
+        return ErrorPackageSpecInvalid(name).to_chain();
     }
 
-    StatePkgDisable::new(name).to_chain()
+    StatePkgDisable(name).to_chain()
 }
 
 #[chain(routeify)]
 pub fn handle_state_pkg_disable(p: StatePkgDisable, packages_dir: &ResPackagesDir) -> Next {
-    let name = p.inner;
+    let name = p.0;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let file = packages_dir.join(&name);
     if !file.is_file() {
-        return ErrorPackageNotEnabled::new(name).to_chain();
+        return ErrorPackageNotEnabled(name).to_chain();
     }
     fs::remove_file(&file).map_err(|e| {
         io::Error::new(
@@ -86,7 +88,7 @@ pub fn render_result_pkg_disable(result: ResultPkgDisable) -> RenderResult {
 #[renderer]
 pub fn render_error_package_not_enabled(err: ErrorPackageNotEnabled) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "package is not enabled: {}", err.info);
+    eprintln_cargo!(r, "package is not enabled: {}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
index 8f6a234..1235cd3 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
@@ -1,8 +1,8 @@
 use std::{fs, io};
 
 use mingling::{
-    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
@@ -18,8 +18,11 @@ use crate::{
 /// Positional argument: package spec (`foo`, `foo@0`, `foo@0.1`, `foo@0.1.2`)
 pub static ARG_SPEC: PickerArg<String> = arg![String];
 
-pack_err!(ErrorNoMatchingVersion = String);
-pack!(StatePkgEnable = (String, String));
+#[derive(Grouped, Wrap)]
+pub struct ErrorNoMatchingVersion(String);
+
+#[derive(Grouped, Wrap)]
+pub struct StatePkgEnable((String, String));
 
 #[derive(Debug, Default, Grouped)]
 pub struct ResultPkgEnable {
@@ -35,14 +38,14 @@ pub fn desc_pkg_enable() -> Description {
 #[command(node = "pkg-enable", routeify)]
 pub fn package_enable(args: EntryPkgEnable, packages_dir: &ResPackagesDir) -> Next {
     let spec = args
-        .pick_or_route(&ARG_SPEC, || ErrorPackageNameRequired::default().to_chain())
+        .pick_or_route(&ARG_SPEC, || ErrorPackageNameRequired.to_chain())
         .to_result()?;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     if spec.contains('/') || spec.contains('\\') || spec.contains("..") {
-        return ErrorPackageSpecInvalid::new(spec).to_chain();
+        return ErrorPackageSpecInvalid(spec).to_chain();
     }
 
     let (name, version_part) = match spec.split_once('@') {
@@ -78,18 +81,18 @@ pub fn package_enable(args: EntryPkgEnable, packages_dir: &ResPackagesDir) -> Ne
     }
 
     let Some((_, version)) = candidates.into_iter().max_by(|a, b| a.1.cmp(&b.1)) else {
-        return ErrorNoMatchingVersion::new(spec).to_chain();
+        return ErrorNoMatchingVersion(spec).to_chain();
     };
 
-    StatePkgEnable::new((name, version.to_string())).to_chain()
+    StatePkgEnable((name, version.to_string())).to_chain()
 }
 
 #[chain(routeify)]
 pub fn handle_state_pkg_enable(p: StatePkgEnable, packages_dir: &ResPackagesDir) -> Next {
-    let (name, version) = p.inner;
+    let (name, version) = p.0;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let file = packages_dir.join(&name);
@@ -110,7 +113,7 @@ pub fn render_result_pkg_enable(result: ResultPkgEnable) -> RenderResult {
 #[renderer]
 pub fn render_error_no_matching_version(err: ErrorNoMatchingVersion) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "no matching version for: {}", err.info);
+    eprintln_cargo!(r, "no matching version for: {}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
index 88c79ef..ea26021 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
@@ -3,7 +3,7 @@ use std::{collections::BTreeMap, fs, io};
 use colored::Colorize;
 use mingling::{
     Grouped, RenderResult, Routable,
-    macros::{buffer, command, metadata, pack_err, r_println, renderer, routeify},
+    macros::{buffer, command, metadata, r_println, renderer, routeify},
     metadata::Description,
 };
 
@@ -15,8 +15,10 @@ use crate::{
 #[derive(Debug, Default, Clone)]
 pub struct PkgShowEntry {
     pub name: String,
+
     /// Enabled version, from the content of the enable file.
     pub enabled: Option<String>,
+
     /// Installed versions, newest first.
     pub versions: Vec<String>,
 }
@@ -31,13 +33,14 @@ pub fn desc_pkg_show() -> Description {
     "Show locally installed packages".into()
 }
 
-pack_err!(ErrorNoPackagesInstalled);
+#[derive(Grouped, Default)]
+pub struct ErrorNoPackagesInstalled;
 
 #[command(node = "pkg-show", routeify)]
 pub fn package_show(packages_dir: &ResPackagesDir) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let mut entries: BTreeMap<String, PkgShowEntry> = BTreeMap::new();
@@ -84,7 +87,7 @@ pub fn package_show(packages_dir: &ResPackagesDir) -> Next {
     let packages: Vec<PkgShowEntry> = entries.into_values().collect();
 
     if packages.is_empty() {
-        return ErrorNoPackagesInstalled::default().into();
+        return ErrorNoPackagesInstalled.into();
     }
 
     ResultPkgShow { packages }.to_chain()
diff --git a/mingling_cli/src/pkg_mgr/cmd_uninstall.rs b/mingling_cli/src/pkg_mgr/cmd_uninstall.rs
index 2b288d6..0c3886c 100644
--- a/mingling_cli/src/pkg_mgr/cmd_uninstall.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_uninstall.rs
@@ -1,8 +1,8 @@
 use std::{fs, io, path::PathBuf};
 
 use mingling::{
-    LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
@@ -20,16 +20,20 @@ use crate::{
 pub static ARG_PACKAGE: PickerArg<Option<String>> = arg![Option<String>];
 
 // Directory names to remove, e.g. `["omg@0.1.0", "omg@0.1.1"]`
-pack!(StateUninstallPackages = Vec<String>);
+#[derive(Grouped, Wrap)]
+pub struct StateUninstallPackages(Vec<String>);
 
 // Directories that were successfully removed.
-pack!(ResultPackageUninstalled = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ResultPackageUninstalled(Vec<PathBuf>);
 
 // Directories that were not installed.
-pack_err!(ErrorPackageNotInstall = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ErrorPackageNotInstall(Vec<PathBuf>);
 
 // No installed package matched the given spec.
-pack_err!(ErrorNoMatchingPackages);
+#[derive(Grouped, Default)]
+pub struct ErrorNoMatchingPackages;
 
 /// `{data_dir}/mingling/packages`
 #[metadata(EntryUninstall)]
@@ -46,7 +50,7 @@ pub fn uninstall(
     let spec = args.pick(&ARG_PACKAGE).to_result()?;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let targets = match spec {
@@ -56,13 +60,13 @@ pub fn uninstall(
             let root_package = metadata
                 .root_package()
                 .or_else(|| metadata.workspace_packages().first().copied())
-                .ok_or(ErrorRootPackageNotFound::default())?;
+                .ok_or(ErrorRootPackageNotFound)?;
             vec![format!("{}@{}", root_package.name, root_package.version)]
         }
         // `name` matches every installed version, `name@version` matches exactly
         Some(spec) => {
             if spec.contains('/') || spec.contains('\\') || spec.contains("..") {
-                return ErrorPackageSpecInvalid::new(spec).to_chain();
+                return ErrorPackageSpecInvalid(spec).to_chain();
             }
             if spec.contains('@') {
                 vec![spec]
@@ -87,7 +91,7 @@ pub fn uninstall(
         }
     };
 
-    StateUninstallPackages::new(targets).to_chain()
+    StateUninstallPackages(targets).to_chain()
 }
 
 #[chain(routeify)]
@@ -97,13 +101,13 @@ pub fn handle_state_uninstall_packages(
 ) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let mut removed = Vec::new();
     let mut not_installed = Vec::new();
 
-    for name in p.inner {
+    for name in p.0 {
         let dir = packages_dir.join(&name);
         if !dir.exists() {
             not_installed.push(dir);
@@ -116,18 +120,18 @@ pub fn handle_state_uninstall_packages(
     }
 
     if removed.is_empty() && not_installed.is_empty() {
-        return ErrorNoMatchingPackages::default().to_chain();
+        return ErrorNoMatchingPackages.to_chain();
     }
     if !removed.is_empty() {
-        return ResultPackageUninstalled::new(removed).to_chain();
+        return ResultPackageUninstalled(removed).to_chain();
     }
-    ErrorPackageNotInstall::new(not_installed).to_chain()
+    ErrorPackageNotInstall(not_installed).to_chain()
 }
 
 #[renderer]
 pub fn render_result_package_uninstalled(r: ResultPackageUninstalled) -> RenderResult {
     let mut result = RenderResult::new();
-    for dir in r.inner {
+    for dir in r.0 {
         println_cargo!(result, "Uninstalled: {}", dir.display());
     }
     result
@@ -136,7 +140,7 @@ pub fn render_result_package_uninstalled(r: ResultPackageUninstalled) -> RenderR
 #[renderer]
 pub fn render_error_package_not_install(err: ErrorPackageNotInstall) -> RenderResult {
     let mut result = RenderResult::new();
-    for dir in err.info {
+    for dir in err.0 {
         eprintln_cargo!(result, "not installed: {}", dir.display());
     }
     result
diff --git a/mingling_cli/src/proj_mgr/cmd_class_add.rs b/mingling_cli/src/proj_mgr/cmd_class_add.rs
index 9c729a9..f9272a5 100644
--- a/mingling_cli/src/proj_mgr/cmd_class_add.rs
+++ b/mingling_cli/src/proj_mgr/cmd_class_add.rs
@@ -6,8 +6,8 @@ use std::{
 use just_fmt::{camel_case, kebab_case, pascal_case, snake_case};
 use just_template::Template;
 use mingling::{
-    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::EntryPicker,
     res::ResCurrentDir,
@@ -29,7 +29,8 @@ pub struct ClassEntry {
     pub description: String,
 }
 
-pack!(StateClassAdd = (String, String));
+#[derive(Grouped, Wrap)]
+pub struct StateClassAdd((String, String));
 
 /// Result of adding a class: the generated file path.
 #[derive(Debug, Default, Grouped)]
@@ -37,19 +38,28 @@ pub struct ResultClassAdd {
     pub output: PathBuf,
 }
 
-pack_err!(ErrorClassNameRequired = ());
-pack_err!(ErrorClassConfigMissing = String);
-pack_err!(ErrorClassNotFound = String);
-pack_err!(ErrorClassTemplateMissing = String);
-pack_err!(ErrorClassWriteFailed = String);
+#[derive(Grouped)]
+pub struct ErrorClassNameRequired;
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorClassConfigMissing(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorClassNotFound(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorClassTemplateMissing(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorClassWriteFailed(String);
 
 #[command(node = "class-add", routeify)]
 pub fn class_add(args: EntryClassAdd) -> Next {
     let (class_name, name) = args
-        .pick_or_route(&arg![String], || ErrorClassNameRequired::new(()).to_chain())
-        .pick_or_route(&arg![String], || ErrorClassNameRequired::new(()).to_chain())
+        .pick_or_route(&arg![String], || ErrorClassNameRequired.to_chain())
+        .pick_or_route(&arg![String], || ErrorClassNameRequired.to_chain())
         .to_result()?;
-    StateClassAdd::new((class_name, name)).to_chain()
+    StateClassAdd((class_name, name)).to_chain()
 }
 
 /// Walk upward from `start` to find the first directory containing `.mling`.
@@ -91,11 +101,11 @@ fn deverbatim(path: &Path) -> PathBuf {
 /// name-derived parameters into `<output-dir>/<snake_case>.rs`.
 #[chain(routeify)]
 pub fn handle_state_class_add(state: StateClassAdd, cwd: &ResCurrentDir) -> Next {
-    let (class_name, name) = state.inner;
+    let (class_name, name) = state.0;
 
     // Resolve the project root: the nearest ancestor directory with `.mling`.
     let Some(project_root) = find_project_root(cwd) else {
-        return ErrorClassConfigMissing::new(format!(
+        return ErrorClassConfigMissing(format!(
             "no `.mling` directory found from {} upward; run this inside a mingling project",
             cwd.display()
         ))
@@ -105,14 +115,14 @@ pub fn handle_state_class_add(state: StateClassAdd, cwd: &ResCurrentDir) -> Next
     // Read `.mling/classes.toml` (the class registry).
     let classes_path = project_root.join(".mling").join("classes.toml");
     let content = fs::read_to_string(&classes_path).map_err(|e| {
-        ErrorClassConfigMissing::new(format!("failed to read {}: {e}", classes_path.display()))
+        ErrorClassConfigMissing(format!("failed to read {}: {e}", classes_path.display()))
     })?;
     let classes = parse_classes(&content)
-        .map_err(|e| ErrorClassConfigMissing::new(format!("invalid classes.toml: {e}")))?;
+        .map_err(|e| ErrorClassConfigMissing(format!("invalid classes.toml: {e}")))?;
 
     // Find the requested class type.
     let Some(entry) = classes.iter().find(|c| c.name == class_name) else {
-        return ErrorClassNotFound::new(format!(
+        return ErrorClassNotFound(format!(
             "class `{class_name}` not found in {}",
             classes_path.display()
         ))
@@ -122,7 +132,7 @@ pub fn handle_state_class_add(state: StateClassAdd, cwd: &ResCurrentDir) -> Next
     // Read the class template (relative to `.mling/`).
     let template_path = project_root.join(".mling").join(&entry.template);
     let template_content = fs::read_to_string(&template_path).map_err(|e| {
-        ErrorClassTemplateMissing::new(format!("failed to read {}: {e}", template_path.display()))
+        ErrorClassTemplateMissing(format!("failed to read {}: {e}", template_path.display()))
     })?;
 
     // Derive the name variants used by the template placeholders.
@@ -139,7 +149,7 @@ pub fn handle_state_class_add(state: StateClassAdd, cwd: &ResCurrentDir) -> Next
     tmpl.insert_param("upper_snake_case".to_string(), upper_snake);
     tmpl.insert_param("camel_case".to_string(), camel);
     let expanded = tmpl.expand().ok_or_else(|| {
-        ErrorClassWriteFailed::new(format!(
+        ErrorClassWriteFailed(format!(
             "failed to expand class template: {}",
             template_path.display()
         ))
@@ -149,11 +159,10 @@ pub fn handle_state_class_add(state: StateClassAdd, cwd: &ResCurrentDir) -> Next
     let output_dir = project_root.join(&entry.output_dir);
     let output = output_dir.join(format!("{snake}.rs"));
     fs::create_dir_all(&output_dir).map_err(|e| {
-        ErrorClassWriteFailed::new(format!("failed to create {}: {e}", output_dir.display()))
-    })?;
-    fs::write(&output, expanded).map_err(|e| {
-        ErrorClassWriteFailed::new(format!("failed to write {}: {e}", output.display()))
+        ErrorClassWriteFailed(format!("failed to create {}: {e}", output_dir.display()))
     })?;
+    fs::write(&output, expanded)
+        .map_err(|e| ErrorClassWriteFailed(format!("failed to write {}: {e}", output.display())))?;
 
     ResultClassAdd { output }.to_chain()
 }
@@ -215,28 +224,28 @@ pub fn render_error_class_name_required(_err: ErrorClassNameRequired) -> RenderR
 #[renderer]
 pub fn render_error_class_config_missing(err: ErrorClassConfigMissing) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_class_not_found(err: ErrorClassNotFound) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_class_template_missing(err: ErrorClassTemplateMissing) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_class_write_failed(err: ErrorClassWriteFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/proj_mgr/cmd_proj_init.rs b/mingling_cli/src/proj_mgr/cmd_proj_init.rs
index 1ef8d1e..edad83c 100644
--- a/mingling_cli/src/proj_mgr/cmd_proj_init.rs
+++ b/mingling_cli/src/proj_mgr/cmd_proj_init.rs
@@ -7,8 +7,8 @@ use std::{
 use just_fmt::snake_case;
 use just_template::Template;
 use mingling::{
-    Grouped, LazyRes, RenderResult, Routable,
-    macros::{arg, chain, command, metadata, pack, pack_err, r_println, renderer, routeify},
+    Grouped, LazyRes, RenderResult, Routable, Wrap,
+    macros::{arg, chain, command, metadata, r_println, renderer, routeify},
     metadata::Description,
     picker::EntryPicker,
     res::ResCurrentDir,
@@ -30,8 +30,11 @@ const RULE_FILENAME: &str = "rule.toml";
 /// The directory under the project root where the template cache lives.
 const CACHE_DIR_NAME: &str = "tmpl-cache";
 
-pack!(StateProjectGenerate = ());
-pack!(StateProjectChecklistReady = Vec<String>);
+#[derive(Grouped)]
+pub struct StateProjectGenerate;
+
+#[derive(Grouped, Wrap)]
+pub struct StateProjectChecklistReady(Vec<String>);
 
 /// Result of the checklist phase: the extracted checklist handed to the user.
 #[derive(Debug, Default, Grouped)]
@@ -46,20 +49,31 @@ pub struct ResultProjectGenerate {
     pub hidden: Vec<PathBuf>,
 }
 
-pack_err!(ErrorTemplateNotProvided = ());
-pack_err!(ErrorTemplateCopyFailed = String);
-pack_err!(ErrorTemplateFetchFailed = String);
-pack_err!(ErrorChecklistMissing = String);
-pack_err!(ErrorRuleParseFailed = String);
-pack_err!(ErrorTemplateExpandFailed = String);
+#[derive(Grouped)]
+pub struct ErrorTemplateNotProvided;
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorTemplateCopyFailed(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorTemplateFetchFailed(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorChecklistMissing(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorRuleParseFailed(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorTemplateExpandFailed(String);
 
 #[command(node = "proj-init", routeify)]
 pub fn proj_init(args: Entry, cwd: &ResCurrentDir) -> Next {
     // Check if the checklist.toml file exists in the current directory
     if cwd.join(CHECKLIST_FILENAME).exists() {
-        StateProjectGenerate::new(()).into()
+        StateProjectGenerate.into()
     } else {
-        StateProjectChecklistReady::new(args.inner).into()
+        StateProjectChecklistReady(args.0).into()
     }
 }
 
@@ -73,7 +87,7 @@ pub fn handle_state_proj_checklist_ready(
 ) -> Next {
     let source: TemplateSource = args
         .pick_or_route(&arg![TemplateSource], || {
-            ErrorTemplateNotProvided::new(()).to_chain()
+            ErrorTemplateNotProvided.to_chain()
         })
         .to_result()?;
 
@@ -88,7 +102,7 @@ pub fn handle_state_proj_checklist_ready(
                 configured
             });
             resolve_git(&source_url, &reference, &variant, &cache_dir())
-                .map_err(ErrorTemplateFetchFailed::new)?
+                .map_err(ErrorTemplateFetchFailed)?
         }
     };
 
@@ -96,15 +110,15 @@ pub fn handle_state_proj_checklist_ready(
     // directory; create it if it doesn't exist
     let tmpl_cache = cwd.join(".mling").join(CACHE_DIR_NAME);
     fs::create_dir_all(&tmpl_cache).map_err(|e| {
-        ErrorTemplateCopyFailed::new(format!("failed to create {}: {e}", tmpl_cache.display()))
+        ErrorTemplateCopyFailed(format!("failed to create {}: {e}", tmpl_cache.display()))
     })?;
     copy_dir_contents(&template_root, &tmpl_cache)
-        .map_err(|e| ErrorTemplateCopyFailed::new(e.to_string()))?;
+        .map_err(|e| ErrorTemplateCopyFailed(e.to_string()))?;
 
     // Move the internal checklist.toml to ./ for the user to fill in
     let checklist_src = tmpl_cache.join(CHECKLIST_FILENAME);
     if !checklist_src.is_file() {
-        return ErrorChecklistMissing::new(format!(
+        return ErrorChecklistMissing(format!(
             "no checklist.toml found inside {}",
             template_root.display()
         ))
@@ -112,7 +126,7 @@ pub fn handle_state_proj_checklist_ready(
     }
     let checklist_dst = cwd.join(CHECKLIST_FILENAME);
     fs::rename(&checklist_src, &checklist_dst).map_err(|e| {
-        ErrorTemplateCopyFailed::new(format!(
+        ErrorTemplateCopyFailed(format!(
             "failed to move checklist.toml to {}: {e}",
             checklist_dst.display()
         ))
@@ -130,7 +144,7 @@ pub fn handle_state_proj_checklist_ready(
 pub fn handle_state_project_generate(_: StateProjectGenerate, cwd: &ResCurrentDir) -> Next {
     let tmpl_cache = cwd.join(".mling").join(CACHE_DIR_NAME);
     if !tmpl_cache.is_dir() {
-        return ErrorChecklistMissing::new(format!(
+        return ErrorChecklistMissing(format!(
             "template cache not found at {}; run `mling proj-init` with a template directory first",
             tmpl_cache.display()
         ))
@@ -140,22 +154,22 @@ pub fn handle_state_project_generate(_: StateProjectGenerate, cwd: &ResCurrentDi
     // Read the user-filled checklist.toml
     let checklist_path = cwd.join(CHECKLIST_FILENAME);
     let checklist_content = fs::read_to_string(&checklist_path).map_err(|e| {
-        ErrorChecklistMissing::new(format!("failed to read {}: {e}", checklist_path.display()))
+        ErrorChecklistMissing(format!("failed to read {}: {e}", checklist_path.display()))
     })?;
     let answers = parse_checklist(&checklist_content)
-        .map_err(|e| ErrorRuleParseFailed::new(format!("invalid checklist.toml: {e}")))?;
+        .map_err(|e| ErrorRuleParseFailed(format!("invalid checklist.toml: {e}")))?;
 
     // Read rule.toml (template rules)
     let rule_content = fs::read_to_string(tmpl_cache.join(RULE_FILENAME))
-        .map_err(|e| ErrorRuleParseFailed::new(format!("failed to read rule.toml: {e}")))?;
+        .map_err(|e| ErrorRuleParseFailed(format!("failed to read rule.toml: {e}")))?;
     let rules = parse_rules(&rule_content)
-        .map_err(|e| ErrorRuleParseFailed::new(format!("invalid rule.toml: {e}")))?;
+        .map_err(|e| ErrorRuleParseFailed(format!("invalid rule.toml: {e}")))?;
 
     // Compute final answers from checklist values + defaults declared in rule.toml
     let answers = resolve_answers(&answers, &rules);
 
     // Mutually exclusive toggle groups must not both be enabled.
-    validate_mutexes(&answers, &rules).map_err(ErrorRuleParseFailed::new)?;
+    validate_mutexes(&answers, &rules).map_err(ErrorRuleParseFailed)?;
 
     // Derive the crate name from the program name (e.g. `my-cli` -> `my_cli`).
     let mut params: HashMap<String, String> = answers.clone();
@@ -171,7 +185,7 @@ pub fn handle_state_project_generate(_: StateProjectGenerate, cwd: &ResCurrentDi
     // Expand all template entries to the project root
     let mut generated = Vec::new();
     expand_tree(&tmpl_cache, cwd, &params, &mut generated, true)
-        .map_err(ErrorTemplateExpandFailed::new)?;
+        .map_err(ErrorTemplateExpandFailed)?;
 
     // hide-file: delete the corresponding generated file when the rule is true
 
@@ -182,7 +196,7 @@ pub fn handle_state_project_generate(_: StateProjectGenerate, cwd: &ResCurrentDi
         }
         let target = cwd.join(hide.file.trim_start_matches("./"));
         remove_path(&target).map_err(|e| {
-            ErrorTemplateExpandFailed::new(format!("failed to hide {}: {e}", target.display()))
+            ErrorTemplateExpandFailed(format!("failed to hide {}: {e}", target.display()))
         })?;
         hidden.push(target);
     }
@@ -194,19 +208,19 @@ pub fn handle_state_project_generate(_: StateProjectGenerate, cwd: &ResCurrentDi
         }
         let target = cwd.join(hide.dir.trim_start_matches("./"));
         remove_path(&target).map_err(|e| {
-            ErrorTemplateExpandFailed::new(format!("failed to hide {}: {e}", target.display()))
+            ErrorTemplateExpandFailed(format!("failed to hide {}: {e}", target.display()))
         })?;
         hidden.push(target);
     }
 
     // Clean up the cache
     fs::remove_dir_all(&tmpl_cache).map_err(|e| {
-        ErrorTemplateExpandFailed::new(format!("failed to remove {}: {e}", tmpl_cache.display()))
+        ErrorTemplateExpandFailed(format!("failed to remove {}: {e}", tmpl_cache.display()))
     })?;
 
     // Project generated; remove the temporary checklist file
     remove_path(&checklist_path).map_err(|e| {
-        ErrorTemplateExpandFailed::new(format!(
+        ErrorTemplateExpandFailed(format!(
             "failed to remove {}: {e}",
             checklist_path.display()
         ))
@@ -327,35 +341,35 @@ pub fn render_error_template_not_provided(_err: ErrorTemplateNotProvided) -> Ren
 #[renderer]
 pub fn render_error_template_copy_failed(err: ErrorTemplateCopyFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "failed to copy template: {}", err.info);
+    eprintln_cargo!(r, "failed to copy template: {}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_template_fetch_failed(err: ErrorTemplateFetchFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "failed to fetch template: {}", err.info);
+    eprintln_cargo!(r, "failed to fetch template: {}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_checklist_missing(err: ErrorChecklistMissing) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_rule_parse_failed(err: ErrorRuleParseFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_template_expand_failed(err: ErrorTemplateExpandFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }