From af15722ce38f4e76cc931dff307390cea3c0a89c Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Wed, 9 Apr 2025 11:25:32 -0400
Subject: [PATCH 01/39] feat: add minijinja dependency and integrate into task
 module

---
 Cargo.lock                       | 1 +
 crates/pixi_manifest/Cargo.toml  | 1 +
 crates/pixi_manifest/src/task.rs | 6 ++++++
 3 files changed, 8 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 292d3f7507..5602065926 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4627,6 +4627,7 @@ dependencies = [
  "insta",
  "itertools 0.14.0",
  "miette 7.5.0",
+ "minijinja",
  "pathdiff",
  "pep440_rs",
  "pep508_rs",
diff --git a/crates/pixi_manifest/Cargo.toml b/crates/pixi_manifest/Cargo.toml
index 515b8ca0ec..d83ea86c34 100644
--- a/crates/pixi_manifest/Cargo.toml
+++ b/crates/pixi_manifest/Cargo.toml
@@ -47,6 +47,7 @@ rattler_solve = { workspace = true, optional = true }
 # TODO: Remove these dependencies
 console = { workspace = true }
 miette = { workspace = true, features = ["fancy-no-backtrace"] }
+minijinja.workspace = true
 
 [dev-dependencies]
 assert_matches = { workspace = true }
diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 08ceb3282d..075cd2bc47 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -8,6 +8,7 @@ use std::{
 
 use indexmap::IndexMap;
 use itertools::Itertools;
+use minijinja::Template;
 use serde::Serialize;
 use toml_edit::{Array, Item, Table, Value};
 
@@ -344,6 +345,11 @@ impl From<Custom> for Task {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct TaskString<'a> {
+    _inner: Template<'a, 'a>,
+}
+
 #[derive(Debug, Clone)]
 pub enum CmdArgs {
     Single(String),

From 0492a3fc5c0ff27635b7c4311ef14416573c4817 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Fri, 11 Apr 2025 09:11:55 -0400
Subject: [PATCH 02/39] feat: continue adding minijinja integration

---
 Cargo.lock                                    |   2 +
 crates/pixi_consts/src/consts.rs              |   1 +
 crates/pixi_manifest/Cargo.toml               |   2 +
 .../pixi_manifest/src/manifests/workspace.rs  |  18 +-
 crates/pixi_manifest/src/task.rs              | 166 +++++++++++++----
 crates/pixi_manifest/src/toml/task.rs         |  14 +-
 crates/pixi_manifest/src/workspace.rs         |   8 +
 src/cli/run.rs                                |   4 +-
 src/cli/task.rs                               |  12 +-
 src/task/executable_task.rs                   | 174 +++++-------------
 src/task/task_graph.rs                        |  24 ++-
 src/task/task_hash.rs                         |   6 +-
 tests/integration_python/test_run_cli.py      |  11 +-
 tests/integration_rust/task_tests.rs          |   9 +-
 14 files changed, 241 insertions(+), 210 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5602065926..301f99357c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4617,6 +4617,7 @@ dependencies = [
 name = "pixi_manifest"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "assert_matches",
  "console",
  "dunce",
@@ -4628,6 +4629,7 @@ dependencies = [
  "itertools 0.14.0",
  "miette 7.5.0",
  "minijinja",
+ "once_cell",
  "pathdiff",
  "pep440_rs",
  "pep508_rs",
diff --git a/crates/pixi_consts/src/consts.rs b/crates/pixi_consts/src/consts.rs
index 837fa6cb2b..af22557737 100644
--- a/crates/pixi_consts/src/consts.rs
+++ b/crates/pixi_consts/src/consts.rs
@@ -89,6 +89,7 @@ pub const CLAP_GLOBAL_OPTIONS: &str = "Global Options";
 pub const CLAP_UPDATE_OPTIONS: &str = "Update Options";
 
 pub static TASK_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().blue());
+pub static TASK_ERROR_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().red());
 pub static PLATFORM_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().yellow());
 pub static ENVIRONMENT_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().magenta());
 pub static EXPOSED_NAME_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().yellow());
diff --git a/crates/pixi_manifest/Cargo.toml b/crates/pixi_manifest/Cargo.toml
index d83ea86c34..8da0649766 100644
--- a/crates/pixi_manifest/Cargo.toml
+++ b/crates/pixi_manifest/Cargo.toml
@@ -45,9 +45,11 @@ rattler_lock = { workspace = true, optional = true }
 rattler_solve = { workspace = true, optional = true }
 
 # TODO: Remove these dependencies
+anyhow = "1.0.97"
 console = { workspace = true }
 miette = { workspace = true, features = ["fancy-no-backtrace"] }
 minijinja.workspace = true
+once_cell.workspace = true
 
 [dev-dependencies]
 assert_matches = { workspace = true }
diff --git a/crates/pixi_manifest/src/manifests/workspace.rs b/crates/pixi_manifest/src/manifests/workspace.rs
index 3bd42d1e04..445f3affec 100644
--- a/crates/pixi_manifest/src/manifests/workspace.rs
+++ b/crates/pixi_manifest/src/manifests/workspace.rs
@@ -1214,13 +1214,13 @@ start = "python -m flask run --port=5050"
             .flat_map(|(target, selector)| {
                 let selector_name =
                     selector.map_or_else(|| String::from("default"), ToString::to_string);
-                target.tasks.iter().filter_map(move |(name, task)| {
-                    Some(format!(
-                        "{}/{} = {}",
+                target.tasks.iter().map(move |(name, task)| {
+                    format!(
+                        "{}/{} = {:?}",
                         &selector_name,
                         name.as_str(),
-                        task.as_single_command()?
-                    ))
+                        task.as_single_command().ok()
+                    )
                 })
             })
             .join("\n"));
@@ -2445,7 +2445,7 @@ test = "test initial"
         manifest
             .add_task(
                 "default".into(),
-                Task::Plain("echo default".to_string()),
+                Task::Plain("echo default".into()),
                 None,
                 &FeatureName::DEFAULT,
             )
@@ -2453,7 +2453,7 @@ test = "test initial"
         manifest
             .add_task(
                 "target_linux".into(),
-                Task::Plain("echo target_linux".to_string()),
+                Task::Plain("echo target_linux".into()),
                 Some(Platform::Linux64),
                 &FeatureName::DEFAULT,
             )
@@ -2461,7 +2461,7 @@ test = "test initial"
         manifest
             .add_task(
                 "feature_test".into(),
-                Task::Plain("echo feature_test".to_string()),
+                Task::Plain("echo feature_test".into()),
                 None,
                 &FeatureName::from("test"),
             )
@@ -2469,7 +2469,7 @@ test = "test initial"
         manifest
             .add_task(
                 "feature_test_target_linux".into(),
-                Task::Plain("echo feature_test_target_linux".to_string()),
+                Task::Plain("echo feature_test_target_linux".into()),
                 Some(Platform::Linux64),
                 &FeatureName::from("test"),
             )
diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 075cd2bc47..f1d58c5366 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -6,9 +6,10 @@ use std::{
     str::FromStr,
 };
 
+use crate::workspace::JINJA_ENV;
 use indexmap::IndexMap;
 use itertools::Itertools;
-use minijinja::Template;
+use miette::IntoDiagnostic;
 use serde::Serialize;
 use toml_edit::{Array, Item, Table, Value};
 
@@ -93,7 +94,7 @@ impl FromStr for TaskName {
 /// Represents different types of scripts
 #[derive(Debug, Clone)]
 pub enum Task {
-    Plain(String),
+    Plain(TaskString),
     Execute(Box<Execute>),
     Alias(Alias),
     Custom(Custom),
@@ -110,26 +111,26 @@ impl Task {
     }
 
     /// If this task is a plain task, returns the task string
-    pub fn as_plain(&self) -> Option<&String> {
+    pub fn as_plain(&self) -> Result<String, miette::Error> {
         match self {
-            Task::Plain(str) => Some(str),
-            _ => None,
+            Task::Plain(str) => str.render(None),
+            _ => Err(miette::miette!("Task is not a plain task")),
         }
     }
 
     /// If this command is an execute command, returns the `Execute` task.
-    pub fn as_execute(&self) -> Option<&Execute> {
+    pub fn as_execute(&self) -> Result<&Execute, miette::Error> {
         match self {
-            Task::Execute(execute) => Some(execute),
-            _ => None,
+            Task::Execute(execute) => Ok(execute),
+            _ => Err(miette::miette!("Task is not an execute task")),
         }
     }
 
     /// If this command is an alias, returns the `Alias` task.
-    pub fn as_alias(&self) -> Option<&Alias> {
+    pub fn as_alias(&self) -> Result<&Alias, miette::Error> {
         match self {
-            Task::Alias(alias) => Some(alias),
-            _ => None,
+            Task::Alias(alias) => Ok(alias),
+            _ => Err(miette::miette!("Task is not an alias task")),
         }
     }
 
@@ -152,12 +153,16 @@ impl Task {
     }
 
     /// Returns the command to execute as a single string.
-    pub fn as_single_command(&self) -> Option<Cow<str>> {
+    pub fn as_single_command(&self) -> Result<Cow<str>, miette::Error> {
+        let args = self.get_args();
         match self {
-            Task::Plain(str) => Some(Cow::Borrowed(str)),
-            Task::Custom(custom) => Some(custom.cmd.as_single()),
-            Task::Execute(exe) => Some(exe.cmd.as_single()),
-            Task::Alias(_) => None,
+            Task::Plain(str) => match str.render(args) {
+                Ok(rendered) => Ok(Cow::Owned(rendered)),
+                Err(e) => Err(e),
+            },
+            Task::Custom(custom) => custom.cmd.as_single(args),
+            Task::Execute(exe) => exe.cmd.as_single(args),
+            Task::Alias(_) => Err(miette::miette!("Alias tasks cannot be executed directly")),
         }
     }
 
@@ -225,7 +230,7 @@ impl Task {
     }
 
     /// Returns the arguments of the task.
-    pub fn get_args(&self) -> Option<&IndexMap<TaskArg, Option<String>>> {
+    pub fn get_args(&self) -> Option<&IndexMap<String, Option<String>>> {
         match self {
             Task::Execute(exe) => exe.args.as_ref(),
             _ => None,
@@ -297,7 +302,7 @@ pub struct Execute {
     pub clean_env: bool,
 
     /// The arguments to pass to the task
-    pub args: Option<IndexMap<TaskArg, Option<String>>>,
+    pub args: Option<IndexMap<String, Option<String>>>,
 }
 
 impl From<Execute> for Task {
@@ -345,43 +350,109 @@ impl From<Custom> for Task {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct TaskString<'a> {
-    _inner: Template<'a, 'a>,
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TaskString {
+    _inner: String,
+}
+
+impl From<&str> for TaskString {
+    fn from(value: &str) -> Self {
+        TaskString {
+            _inner: value.to_string(),
+        }
+    }
+}
+
+impl From<String> for TaskString {
+    fn from(value: String) -> Self {
+        TaskString { _inner: value }
+    }
+}
+
+impl TaskString {
+    // TODO: enable feature for serialize
+    // TODO: check if the Minijinja Value can be used.
+    pub fn render(
+        &self,
+        argsmap: Option<&IndexMap<String, Option<String>>>,
+    ) -> Result<String, miette::Error> {
+        if let Some(argsmap) = argsmap {
+            // If any of the values are None, we should error
+            if argsmap.values().any(|v| v.is_none()) {
+                let undefined_arg = argsmap
+                    .iter()
+                    .find_map(|(k, v)| if v.is_none() { Some(k) } else { None })
+                    .unwrap();
+                return Err(anyhow::anyhow!(
+                    "No value provided for argument '{}'",
+                    undefined_arg
+                ));
+            }
+            return JINJA_ENV
+                .render_str(&self._inner, argsmap)
+                .into_diagnostic();
+        }
+
+        JINJA_ENV.render_str(&self._inner, ()).into_diagnostic()
+    }
 }
 
 #[derive(Debug, Clone)]
 pub enum CmdArgs {
-    Single(String),
-    Multiple(Vec<String>),
+    Single(TaskString),
+    Multiple(Vec<TaskString>),
 }
 
-impl From<Vec<String>> for CmdArgs {
-    fn from(value: Vec<String>) -> Self {
+impl From<Vec<TaskString>> for CmdArgs {
+    fn from(value: Vec<TaskString>) -> Self {
         CmdArgs::Multiple(value)
     }
 }
 
-impl From<String> for CmdArgs {
-    fn from(value: String) -> Self {
+impl From<TaskString> for CmdArgs {
+    fn from(value: TaskString) -> Self {
         CmdArgs::Single(value)
     }
 }
 
 impl CmdArgs {
     /// Returns a single string representation of the command arguments.
-    pub fn as_single(&self) -> Cow<str> {
+    pub fn as_single(
+        &self,
+        argsmap: Option<&IndexMap<String, Option<String>>>,
+    ) -> Result<Cow<str>, miette::Error> {
         match self {
-            CmdArgs::Single(cmd) => Cow::Borrowed(cmd),
-            CmdArgs::Multiple(args) => Cow::Owned(args.iter().map(|arg| quote(arg)).join(" ")),
+            CmdArgs::Single(cmd) => Ok(Cow::Owned(cmd.render(argsmap)?)),
+            CmdArgs::Multiple(args) => {
+                let mut rendered_args = Vec::new();
+                for arg in args {
+                    let rendered = arg.render(argsmap)?;
+                    rendered_args.push(quote(&rendered).to_string());
+                }
+                Ok(Cow::Owned(rendered_args.join(" ")))
+            }
         }
     }
 
     /// Returns a single string representation of the command arguments.
-    pub fn into_single(self) -> String {
+    pub fn into_single(
+        self,
+        argsmap: Option<&IndexMap<String, Option<String>>>,
+    ) -> Result<String, miette::Error> {
         match self {
-            CmdArgs::Single(cmd) => cmd,
-            CmdArgs::Multiple(args) => args.iter().map(|arg| quote(arg)).join(" "),
+            CmdArgs::Single(cmd) => cmd.render(argsmap),
+            CmdArgs::Multiple(args) => {
+                let rendered_args = args
+                    .iter()
+                    .map(|arg| {
+                        Ok(match arg.render(argsmap) {
+                            Ok(rendered) => quote(&rendered).to_string(),
+                            Err(e) => return Err(e),
+                        })
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+                Ok(rendered_args.join(" "))
+            }
         }
     }
 }
@@ -399,11 +470,19 @@ impl Display for Task {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Task::Plain(cmd) => {
-                write!(f, "{}", cmd)?;
+                write!(f, "{}", cmd.render(None).unwrap())?;
             }
-            Task::Execute(cmd) => match &cmd.cmd {
-                CmdArgs::Single(cmd) => write!(f, "{}", cmd)?,
-                CmdArgs::Multiple(mult) => write!(f, "{}", mult.join(" "))?,
+            Task::Execute(execute) => match &execute.cmd {
+                CmdArgs::Single(cmd) => {
+                    write!(f, "{}", cmd.render(execute.args.as_ref()).unwrap())?
+                }
+                CmdArgs::Multiple(mult) => write!(
+                    f,
+                    "{}",
+                    mult.iter()
+                        .map(|arg| arg.render(execute.args.as_ref()).unwrap())
+                        .join(" ")
+                )?,
             },
             _ => {}
         };
@@ -457,15 +536,22 @@ pub fn quote(in_str: &str) -> Cow<str> {
 impl From<Task> for Item {
     fn from(value: Task) -> Self {
         match value {
-            Task::Plain(str) => Item::Value(str.into()),
+            Task::Plain(str) => Item::Value(str.render(None).unwrap().into()),
             Task::Execute(process) => {
                 let mut table = Table::new().into_inline_table();
                 match process.cmd {
                     CmdArgs::Single(cmd_str) => {
-                        table.insert("cmd", cmd_str.into());
+                        table.insert("cmd", cmd_str.render(process.args.as_ref()).unwrap().into());
                     }
                     CmdArgs::Multiple(cmd_strs) => {
-                        table.insert("cmd", Value::Array(Array::from_iter(cmd_strs)));
+                        table.insert(
+                            "cmd",
+                            Value::Array(Array::from_iter(
+                                cmd_strs
+                                    .iter()
+                                    .map(|arg| arg.render(process.args.as_ref()).unwrap()),
+                            )),
+                        );
                     }
                 }
                 if !process.depends_on.is_empty() {
diff --git a/crates/pixi_manifest/src/toml/task.rs b/crates/pixi_manifest/src/toml/task.rs
index b4ae261bca..5a28d80afc 100644
--- a/crates/pixi_manifest/src/toml/task.rs
+++ b/crates/pixi_manifest/src/toml/task.rs
@@ -41,7 +41,7 @@ pub type TomlTask = WithWarnings<Task>;
 impl<'de> toml_span::Deserialize<'de> for TomlTask {
     fn deserialize(value: &mut toml_span::Value<'de>) -> Result<Self, DeserError> {
         let mut th = match value.take() {
-            ValueInner::String(str) => return Ok(Task::Plain(str.into_owned()).into()),
+            ValueInner::String(str) => return Ok(Task::Plain(str.into_owned().into()).into()),
             ValueInner::Table(table) => TableHelper::from((table, value.span)),
             ValueInner::Array(array) => {
                 let mut deps = Vec::new();
@@ -208,7 +208,11 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
                 env,
                 description,
                 clean_env,
-                args: args.map(|args| args.into_iter().map(|arg| (arg, None)).collect()),
+                args: args.map(|args| {
+                    args.into_iter()
+                        .map(|arg| (arg.name, arg.default))
+                        .collect()
+                }),
             }))
         } else {
             let depends_on = depends_on(&mut th).unwrap_or_default();
@@ -228,13 +232,15 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
 impl<'de> toml_span::Deserialize<'de> for CmdArgs {
     fn deserialize(value: &mut toml_span::Value<'de>) -> Result<Self, DeserError> {
         match value.take() {
-            ValueInner::String(str) => Ok(CmdArgs::Single(str.into_owned())),
+            ValueInner::String(str) => Ok(CmdArgs::Single(str.into_owned().into())),
             ValueInner::Array(arr) => {
                 let mut args = Vec::with_capacity(arr.len());
                 for mut item in arr {
                     args.push(item.take_string(None)?.into_owned());
                 }
-                Ok(CmdArgs::Multiple(args))
+                Ok(CmdArgs::Multiple(
+                    args.into_iter().map(|s| s.into()).collect(),
+                ))
             }
             inner => Err(expected("string or array", inner, value.span).into()),
         }
diff --git a/crates/pixi_manifest/src/workspace.rs b/crates/pixi_manifest/src/workspace.rs
index 42ccb05f08..ff110d1834 100644
--- a/crates/pixi_manifest/src/workspace.rs
+++ b/crates/pixi_manifest/src/workspace.rs
@@ -9,6 +9,14 @@ use url::Url;
 
 use super::pypi::pypi_options::PypiOptions;
 use crate::{preview::Preview, PrioritizedChannel, S3Options, Targets};
+use minijinja::{Environment, UndefinedBehavior};
+use once_cell::sync::Lazy;
+
+pub static JINJA_ENV: Lazy<Environment<'static>> = Lazy::new(|| {
+    let mut env = Environment::new();
+    env.set_undefined_behavior(UndefinedBehavior::Strict);
+    env
+});
 
 /// Describes the contents of the `[workspace]` section of the project manifest.
 #[derive(Debug, Default, Clone)]
diff --git a/src/cli/run.rs b/src/cli/run.rs
index bbdf3368cd..fb0a1083c5 100644
--- a/src/cli/run.rs
+++ b/src/cli/run.rs
@@ -191,9 +191,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
                 eprintln!();
             }
 
-            let display_command = executable_task
-                .replace_args(&executable_task.display_command().to_string())
-                .unwrap_or_else(|_| executable_task.display_command().to_string());
+            let display_command = executable_task.display_command().to_string();
 
             eprintln!(
                 "{}{}{}{}{}{}{}",
diff --git a/src/cli/task.rs b/src/cli/task.rs
index a21f90b682..95235ca0c8 100644
--- a/src/cli/task.rs
+++ b/src/cli/task.rs
@@ -192,7 +192,7 @@ impl From<AddArgs> for Task {
             && value.env.is_empty()
             && description.is_none()
         {
-            Self::Plain(cmd_args)
+            Self::Plain(cmd_args.into())
         } else {
             let clean_env = value.clean_env;
             let cwd = value.cwd;
@@ -208,7 +208,7 @@ impl From<AddArgs> for Task {
             let args = value.args;
 
             Self::Execute(Box::new(Execute {
-                cmd: CmdArgs::Single(cmd_args),
+                cmd: CmdArgs::Single(cmd_args.into()),
                 depends_on,
                 inputs: None,
                 outputs: None,
@@ -216,7 +216,11 @@ impl From<AddArgs> for Task {
                 env,
                 description,
                 clean_env,
-                args: args.map(|args| args.into_iter().map(|arg| (arg, None)).collect()),
+                args: args.map(|args| {
+                    args.into_iter()
+                        .map(|arg| (arg.name, arg.default))
+                        .collect()
+                }),
             }))
         }
     }
@@ -560,7 +564,7 @@ pub struct TaskInfo {
 impl From<&Task> for TaskInfo {
     fn from(task: &Task) -> Self {
         TaskInfo {
-            cmd: task.as_single_command().map(|cmd| cmd.to_string()),
+            cmd: task.as_single_command().map(|cmd| cmd.to_string()).ok(),
             description: task.description().map(|desc| desc.to_string()),
             depends_on: task.depends_on().to_vec(),
             cwd: task.working_directory().map(PathBuf::from),
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index b4106f47aa..c8bc3037d8 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -15,7 +15,6 @@ use pixi_consts::consts;
 use pixi_manifest::{Task, TaskName};
 use pixi_progress::await_in_progress;
 use rattler_lock::LockFile;
-use regex;
 use thiserror::Error;
 use tokio::task::JoinHandle;
 
@@ -161,55 +160,9 @@ impl<'p> ExecutableTask<'p> {
     pub(crate) fn project(&self) -> &'p Workspace {
         self.workspace
     }
-    /// Replaces the arguments in the task with the values from the task args.
-    pub fn replace_args(&self, task: &str) -> Result<String, ShellParsingError> {
-        let mut task = task.to_string();
-        if let Some(args) = self.task().get_args() {
-            for (arg, value) in args {
-                // Match {{ arg_name }} with flexible whitespace
-                let pattern = format!(r"\{{\{{\s*{}\s*\}}\}}", regex::escape(&arg.name));
-                let replacement = match value {
-                    Some(val) => val,
-                    None => arg.default.as_deref().ok_or_else(|| {
-                        ShellParsingError::ArgumentReplacement {
-                            source: anyhow::Error::msg(format!(
-                                "no value provided for argument '{}'",
-                                arg.name,
-                            )),
-                            task: task.to_string(),
-                        }
-                    })?,
-                };
-                task = regex::Regex::new(&pattern)
-                    .map_err(|e| ShellParsingError::ArgumentReplacement {
-                        source: e.into(),
-                        task: task.to_string(),
-                    })?
-                    .replace_all(&task, replacement)
-                    .into_owned();
-            }
-        }
-
-        // Check if there are any remaining {{ name }} patterns
-        let remaining_pattern = regex::Regex::new(r"\{\{\s*[\w\-\.]+\s*\}\}").map_err(|e| {
-            ShellParsingError::ArgumentReplacement {
-                source: e.into(),
-                task: task.to_string(),
-            }
-        })?;
-
-        if remaining_pattern.is_match(&task) {
-            return Err(ShellParsingError::ArgumentReplacement {
-                source: anyhow::Error::msg("unresolved argument placeholders found"),
-                task: task.to_string(),
-            });
-        }
-
-        Ok(task)
-    }
 
     /// Returns the task as script
-    fn as_script(&self) -> Option<String> {
+    fn as_script(&self) -> Result<String, miette::Error> {
         // Convert the task into an executable string
         let task = self.task.as_single_command()?;
 
@@ -229,7 +182,7 @@ impl<'p> ExecutableTask<'p> {
             format!("{export}\n{task} {cli_args}")
         };
 
-        Some(full_script)
+        Ok(full_script)
     }
 
     /// Returns a [`SequentialList`] which can be executed by deno task shell.
@@ -238,30 +191,25 @@ impl<'p> ExecutableTask<'p> {
     pub(crate) fn as_deno_script(
         &self,
     ) -> Result<Option<SequentialList>, FailedToParseShellScript> {
-        if let Some(full_script) = self.as_script() {
-            tracing::debug!("Parsing shell script: {}", full_script);
-
-            // Replace the arguments with the values
-            let full_script =
-                self.replace_args(&full_script)
-                    .map_err(|e| FailedToParseShellScript {
-                        script: full_script,
-                        error: e,
-                    })?;
-
-            // Parse the shell command
-            deno_task_shell::parser::parse(full_script.trim())
-                .map_err(|e| FailedToParseShellScript {
-                    script: full_script.clone(),
-                    error: ShellParsingError::ParseError {
-                        source: e,
-                        task: full_script,
-                    },
-                })
-                .map(Some)
-        } else {
-            Ok(None)
-        }
+        let full_script = self.as_script().map_err(|e| FailedToParseShellScript {
+            script: "".to_string(),
+            error: ShellParsingError::ArgumentReplacement {
+                source: e,
+                task: "".to_string(),
+            },
+        })?;
+        tracing::debug!("Parsing shell script: {}", full_script);
+
+        // Parse the shell command
+        deno_task_shell::parser::parse(full_script.trim())
+            .map_err(|e| FailedToParseShellScript {
+                script: full_script.clone(),
+                error: ShellParsingError::ParseError {
+                    source: e,
+                    task: full_script,
+                },
+            })
+            .map(Some)
     }
 
     /// Returns the working directory for this task.
@@ -287,7 +235,7 @@ impl<'p> ExecutableTask<'p> {
     ///
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
-    pub(crate) fn full_command(&self) -> Option<String> {
+    pub(crate) fn full_command(&self) -> Result<String, miette::Error> {
         let mut cmd = self.task.as_single_command()?.to_string();
 
         if !self.additional_args.is_empty() {
@@ -295,7 +243,7 @@ impl<'p> ExecutableTask<'p> {
             cmd.push_str(&self.additional_args.join(" "));
         }
 
-        Some(cmd)
+        Ok(cmd)
     }
 
     /// Returns an object that implements [`Display`] which outputs the command
@@ -413,22 +361,31 @@ struct ExecutableTaskConsoleDisplay<'p, 't> {
 
 impl Display for ExecutableTaskConsoleDisplay<'_, '_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let command = self.task.task.as_single_command();
-        write!(
-            f,
-            "{}",
-            consts::TASK_STYLE
-                .apply_to(command.as_deref().unwrap_or("<alias>"))
-                .bold()
-        )?;
-        if !self.task.additional_args.is_empty() {
-            write!(
-                f,
-                " {}",
-                consts::TASK_STYLE.apply_to(self.task.additional_args.iter().format(" "))
-            )?;
+        match self.task.task.as_single_command() {
+            Ok(command) => {
+                write!(
+                    f,
+                    "{}",
+                    consts::TASK_STYLE
+                        .apply_to(match std::convert::AsRef::<str>::as_ref(&command) {
+                            "" => "<alias>",
+                            cmd => cmd,
+                        })
+                        .bold()
+                )?;
+                if !self.task.additional_args.is_empty() {
+                    write!(
+                        f,
+                        " {}",
+                        consts::TASK_STYLE.apply_to(self.task.additional_args.iter().format(" "))
+                    )?;
+                }
+                Ok(())
+            }
+            Err(err) => {
+                write!(f, "{}", consts::TASK_ERROR_STYLE.apply_to(err).bold())
+            }
         }
-        Ok(())
     }
 }
 /// Helper function to create a pipe that we can get the output from.
@@ -590,41 +547,4 @@ mod tests {
                 .to_string()
         );
     }
-
-    #[test]
-    fn test_replace_args() {
-        let file_contents = r#"
-            [tasks]
-            simple = {cmd = "echo Simple task"}
-        "#;
-
-        let workspace = Workspace::from_str(
-            Path::new("pixi.toml"),
-            &format!("{PROJECT_BOILERPLATE}\n{file_contents}"),
-        )
-        .unwrap();
-
-        let task = workspace
-            .default_environment()
-            .task(&TaskName::from("simple"), None)
-            .unwrap();
-
-        let executable_task = ExecutableTask {
-            workspace: &workspace,
-            name: Some("simple".into()),
-            task: Cow::Borrowed(task),
-            run_environment: workspace.default_environment(),
-            additional_args: vec![],
-        };
-
-        // Test a command with no placeholders works fine
-        let result = executable_task
-            .replace_args("echo No placeholders here")
-            .unwrap();
-        assert_eq!(result, "echo No placeholders here");
-
-        // Test that using an undefined argument errors
-        let result = executable_task.replace_args("echo {{ undefined }}");
-        assert!(result.is_err());
-    }
 }
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index b699a61226..e9246f3d77 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -89,17 +89,24 @@ impl TaskNode<'_> {
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
     #[cfg(test)]
-    pub(crate) fn full_command(&self) -> Option<String> {
-        let mut cmd = self.task.as_single_command()?.to_string();
+    pub(crate) fn full_command(&self) -> Result<String, miette::Error> {
+        let mut cmd = self.task.as_single_command()?;
 
         if let Some(additional_args) = &self.additional_args {
             if !additional_args.is_empty() {
                 // Pass each additional argument varbatim by wrapping it in single quotes
-                cmd.push_str(&format!(" {}", self.format_additional_args()));
+                let formatted_args = format!(" {}", self.format_additional_args());
+                cmd = match cmd {
+                    Cow::Borrowed(s) => Cow::Owned(format!("{}{}", s, formatted_args)),
+                    Cow::Owned(mut s) => {
+                        s.push_str(&formatted_args);
+                        Cow::Owned(s)
+                    }
+                };
             }
         }
 
-        Some(cmd)
+        Ok(cmd.into_owned())
     }
 
     /// Format the additional arguments passed to this command
@@ -241,11 +248,14 @@ impl<'p> TaskGraph<'p> {
         let (cmd, additional_args) = if verbatim {
             let mut args = args.into_iter();
             (
-                CmdArgs::Single(args.next().expect("must be at least one argument")),
+                CmdArgs::Single(args.next().expect("must be at least one argument").into()),
                 args.collect(),
             )
         } else {
-            (CmdArgs::Multiple(args), vec![])
+            (
+                CmdArgs::Multiple(args.into_iter().map(|arg| arg.into()).collect()),
+                vec![],
+            )
         };
 
         Self::from_root(
@@ -458,7 +468,7 @@ mod test {
             .topological_order()
             .into_iter()
             .map(|task| &graph[task])
-            .filter_map(|task| task.full_command())
+            .filter_map(|task| task.full_command().ok())
             .collect()
     }
 
diff --git a/src/task/task_hash.rs b/src/task/task_hash.rs
index 65242cc3ef..d8f74cf4d7 100644
--- a/src/task/task_hash.rs
+++ b/src/task/task_hash.rs
@@ -118,7 +118,7 @@ impl TaskHash {
         }
 
         Ok(Some(Self {
-            command: task.full_command(),
+            command: task.full_command().ok(),
             outputs: output_hashes,
             inputs: input_hashes,
             // Skipping environment variables used for caching the task
@@ -158,7 +158,7 @@ pub struct InputHashes {
 impl InputHashes {
     /// Compute the input hashes from a task.
     pub async fn from_task(task: &ExecutableTask<'_>) -> Result<Option<Self>, InputHashesError> {
-        let Some(ref inputs) = task.task().as_execute().and_then(|e| e.inputs.clone()) else {
+        let Ok(Some(ref inputs)) = task.task().as_execute().map(|e| e.inputs.clone()) else {
             return Ok(None);
         };
 
@@ -192,7 +192,7 @@ impl OutputHashes {
         task: &ExecutableTask<'_>,
         warn: bool,
     ) -> Result<Option<Self>, InputHashesError> {
-        let Some(ref outputs) = task.task().as_execute().and_then(|e| e.outputs.clone()) else {
+        let Ok(Some(ref outputs)) = task.task().as_execute().map(|e| e.outputs.clone()) else {
             return Ok(None);
         };
 
diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index 489444ec30..0e10ccc7b0 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -402,15 +402,6 @@ def test_run_dry_run(pixi: Path, tmp_pixi_workspace: Path) -> None:
     )
 
 
-def test_run_args(pixi: Path, tmp_pixi_workspace: Path) -> None:
-    manifest = tmp_pixi_workspace.joinpath("pixi.toml")
-    toml = f"""
-    {EMPTY_BOILERPLATE_PROJECT}
-    [tasks]
-    """
-    manifest.write_text(toml)
-
-
 def test_invalid_task_args(pixi: Path, tmp_pixi_workspace: Path) -> None:
     manifest_path = tmp_pixi_workspace.joinpath("pixi.toml")
 
@@ -573,7 +564,7 @@ def test_task_args_all_required(pixi: Path, tmp_pixi_workspace: Path) -> None:
     verify_cli_command(
         [pixi, "run", "--manifest-path", manifest_path, "task_all_required", "val1"],
         ExitCode.FAILURE,
-        stderr_contains="no value provided for argument 'arg2'",
+        stderr_contains="No value provided for argument 'arg2'",
     )
 
 
diff --git a/tests/integration_rust/task_tests.rs b/tests/integration_rust/task_tests.rs
index 64c17cfc1d..8b05204b56 100644
--- a/tests/integration_rust/task_tests.rs
+++ b/tests/integration_rust/task_tests.rs
@@ -4,7 +4,10 @@ use pixi::{
     cli::{cli_config::WorkspaceConfig, run::Args},
     task::TaskName,
 };
-use pixi_manifest::{task::CmdArgs, FeatureName, Task};
+use pixi_manifest::{
+    task::{CmdArgs, TaskString},
+    FeatureName, Task,
+};
 use rattler_conda_types::Platform;
 
 use crate::common::PixiControl;
@@ -25,7 +28,7 @@ pub async fn add_remove_task() {
     let project = pixi.workspace().unwrap();
     let tasks = project.default_environment().tasks(None).unwrap();
     let task = tasks.get(&<TaskName>::from("test")).unwrap();
-    assert!(matches!(task, Task::Plain(s) if s == "echo hello"));
+    assert!(matches!(task, Task::Plain(s) if *s == TaskString::from("echo hello")));
 
     // Remove the task
     pixi.tasks()
@@ -154,7 +157,7 @@ pub async fn add_remove_target_specific_task() {
         .unwrap()
         .get(&<TaskName>::from("test"))
         .unwrap();
-    assert!(matches!(task, Task::Plain(s) if s == "echo only_on_windows"));
+    assert!(matches!(task, Task::Plain(s) if *s == TaskString::from("echo only_on_windows")));
 
     // Simple task
     pixi.tasks()

From a581ac3b13c83b70241c0f27b4ee6d76c2a83e0d Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Fri, 11 Apr 2025 15:58:43 -0400
Subject: [PATCH 03/39] fix error type:

---
 crates/pixi_manifest/src/task.rs         | 65 +++++++++++++++++-------
 crates/pixi_manifest/src/workspace.rs    |  3 +-
 src/task/executable_task.rs              | 29 ++++++++---
 src/task/task_graph.rs                   |  2 +-
 tests/integration_python/test_run_cli.py |  2 +-
 tests/integration_rust/task_tests.rs     |  6 +--
 6 files changed, 75 insertions(+), 32 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index f1d58c5366..3dfffe3e0c 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -9,8 +9,9 @@ use std::{
 use crate::workspace::JINJA_ENV;
 use indexmap::IndexMap;
 use itertools::Itertools;
-use miette::IntoDiagnostic;
+use miette::Diagnostic;
 use serde::Serialize;
+use thiserror::Error;
 use toml_edit::{Array, Item, Table, Value};
 
 use crate::EnvironmentName;
@@ -111,26 +112,29 @@ impl Task {
     }
 
     /// If this task is a plain task, returns the task string
-    pub fn as_plain(&self) -> Result<String, miette::Error> {
+    pub fn as_plain(&self) -> Result<String, TaskStringError> {
         match self {
             Task::Plain(str) => str.render(None),
-            _ => Err(miette::miette!("Task is not a plain task")),
+            _ => Err(TaskStringError {
+                source: anyhow::anyhow!("Task is not a plain task"),
+                task: self.to_string(),
+            }),
         }
     }
 
     /// If this command is an execute command, returns the `Execute` task.
-    pub fn as_execute(&self) -> Result<&Execute, miette::Error> {
+    pub fn as_execute(&self) -> Result<&Execute, anyhow::Error> {
         match self {
             Task::Execute(execute) => Ok(execute),
-            _ => Err(miette::miette!("Task is not an execute task")),
+            _ => Err(anyhow::anyhow!("Task is not an execute task")),
         }
     }
 
     /// If this command is an alias, returns the `Alias` task.
-    pub fn as_alias(&self) -> Result<&Alias, miette::Error> {
+    pub fn as_alias(&self) -> Result<&Alias, anyhow::Error> {
         match self {
             Task::Alias(alias) => Ok(alias),
-            _ => Err(miette::miette!("Task is not an alias task")),
+            _ => Err(anyhow::anyhow!("Task is not an alias task")),
         }
     }
 
@@ -153,7 +157,7 @@ impl Task {
     }
 
     /// Returns the command to execute as a single string.
-    pub fn as_single_command(&self) -> Result<Cow<str>, miette::Error> {
+    pub fn as_single_command(&self) -> Result<Cow<str>, TaskStringError> {
         let args = self.get_args();
         match self {
             Task::Plain(str) => match str.render(args) {
@@ -162,7 +166,10 @@ impl Task {
             },
             Task::Custom(custom) => custom.cmd.as_single(args),
             Task::Execute(exe) => exe.cmd.as_single(args),
-            Task::Alias(_) => Err(miette::miette!("Alias tasks cannot be executed directly")),
+            Task::Alias(_) => Err(TaskStringError {
+                source: anyhow::anyhow!("Alias tasks cannot be executed directly"),
+                task: self.to_string(),
+            }),
         }
     }
 
@@ -350,6 +357,20 @@ impl From<Custom> for Task {
     }
 }
 
+/// Represents an error while rendering a task string
+#[derive(Debug, Error, Diagnostic)]
+pub struct TaskStringError {
+    #[source]
+    pub source: anyhow::Error,
+    pub task: String,
+}
+
+impl std::fmt::Display for TaskStringError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.task)
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct TaskString {
     _inner: String,
@@ -375,7 +396,7 @@ impl TaskString {
     pub fn render(
         &self,
         argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<String, miette::Error> {
+    ) -> Result<String, TaskStringError> {
         if let Some(argsmap) = argsmap {
             // If any of the values are None, we should error
             if argsmap.values().any(|v| v.is_none()) {
@@ -383,17 +404,25 @@ impl TaskString {
                     .iter()
                     .find_map(|(k, v)| if v.is_none() { Some(k) } else { None })
                     .unwrap();
-                return Err(anyhow::anyhow!(
-                    "No value provided for argument '{}'",
-                    undefined_arg
-                ));
+                return Err(TaskStringError {
+                    source: anyhow::anyhow!("No value provided for argument '{}'", undefined_arg),
+                    task: self._inner.clone(),
+                });
             }
             return JINJA_ENV
                 .render_str(&self._inner, argsmap)
-                .into_diagnostic();
+                .map_err(|e| TaskStringError {
+                    source: e.into(),
+                    task: self._inner.clone(),
+                });
         }
 
-        JINJA_ENV.render_str(&self._inner, ()).into_diagnostic()
+        JINJA_ENV
+            .render_str(&self._inner, ())
+            .map_err(|e| TaskStringError {
+                source: e.into(),
+                task: self._inner.clone(),
+            })
     }
 }
 
@@ -420,7 +449,7 @@ impl CmdArgs {
     pub fn as_single(
         &self,
         argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<Cow<str>, miette::Error> {
+    ) -> Result<Cow<str>, TaskStringError> {
         match self {
             CmdArgs::Single(cmd) => Ok(Cow::Owned(cmd.render(argsmap)?)),
             CmdArgs::Multiple(args) => {
@@ -438,7 +467,7 @@ impl CmdArgs {
     pub fn into_single(
         self,
         argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<String, miette::Error> {
+    ) -> Result<String, TaskStringError> {
         match self {
             CmdArgs::Single(cmd) => cmd.render(argsmap),
             CmdArgs::Multiple(args) => {
diff --git a/crates/pixi_manifest/src/workspace.rs b/crates/pixi_manifest/src/workspace.rs
index ff110d1834..f73ef947b8 100644
--- a/crates/pixi_manifest/src/workspace.rs
+++ b/crates/pixi_manifest/src/workspace.rs
@@ -9,12 +9,13 @@ use url::Url;
 
 use super::pypi::pypi_options::PypiOptions;
 use crate::{preview::Preview, PrioritizedChannel, S3Options, Targets};
-use minijinja::{Environment, UndefinedBehavior};
+use minijinja::{AutoEscape, Environment, UndefinedBehavior};
 use once_cell::sync::Lazy;
 
 pub static JINJA_ENV: Lazy<Environment<'static>> = Lazy::new(|| {
     let mut env = Environment::new();
     env.set_undefined_behavior(UndefinedBehavior::Strict);
+    env.set_auto_escape_callback(|_| AutoEscape::None);
     env
 });
 
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index c8bc3037d8..6892421e75 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -12,7 +12,7 @@ use fs_err::tokio as tokio_fs;
 use itertools::Itertools;
 use miette::{Context, Diagnostic};
 use pixi_consts::consts;
-use pixi_manifest::{Task, TaskName};
+use pixi_manifest::{task::TaskStringError, Task, TaskName};
 use pixi_progress::await_in_progress;
 use rattler_lock::LockFile;
 use thiserror::Error;
@@ -45,6 +45,14 @@ pub enum ShellParsingError {
     },
 }
 
+impl ShellParsingError {
+    pub fn task(&self) -> &str {
+        match self {
+            ShellParsingError::ParseError { task, .. } => task,
+            ShellParsingError::ArgumentReplacement { task, .. } => task,
+        }
+    }
+}
 /// Runs task in project.
 #[derive(Default, Debug)]
 pub struct RunOutput {
@@ -88,6 +96,14 @@ pub enum CacheUpdateError {
     Serialization(#[from] serde_json::Error),
 }
 
+impl From<TaskStringError> for ShellParsingError {
+    fn from(value: TaskStringError) -> Self {
+        ShellParsingError::ArgumentReplacement {
+            source: value.source,
+            task: value.task,
+        }
+    }
+}
 pub enum CanSkip {
     Yes,
     No(Option<TaskHash>),
@@ -162,7 +178,7 @@ impl<'p> ExecutableTask<'p> {
     }
 
     /// Returns the task as script
-    fn as_script(&self) -> Result<String, miette::Error> {
+    fn as_script(&self) -> Result<String, ShellParsingError> {
         // Convert the task into an executable string
         let task = self.task.as_single_command()?;
 
@@ -192,11 +208,8 @@ impl<'p> ExecutableTask<'p> {
         &self,
     ) -> Result<Option<SequentialList>, FailedToParseShellScript> {
         let full_script = self.as_script().map_err(|e| FailedToParseShellScript {
-            script: "".to_string(),
-            error: ShellParsingError::ArgumentReplacement {
-                source: e,
-                task: "".to_string(),
-            },
+            script: e.task().to_string(),
+            error: e,
         })?;
         tracing::debug!("Parsing shell script: {}", full_script);
 
@@ -235,7 +248,7 @@ impl<'p> ExecutableTask<'p> {
     ///
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
-    pub(crate) fn full_command(&self) -> Result<String, miette::Error> {
+    pub(crate) fn full_command(&self) -> Result<String, anyhow::Error> {
         let mut cmd = self.task.as_single_command()?.to_string();
 
         if !self.additional_args.is_empty() {
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index e9246f3d77..cd43268579 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -89,7 +89,7 @@ impl TaskNode<'_> {
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
     #[cfg(test)]
-    pub(crate) fn full_command(&self) -> Result<String, miette::Error> {
+    pub(crate) fn full_command(&self) -> Result<String, anyhow::Error> {
         let mut cmd = self.task.as_single_command()?;
 
         if let Some(additional_args) = &self.additional_args {
diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index 0e10ccc7b0..999fd0299c 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -751,7 +751,7 @@ def test_depends_on_with_complex_args(pixi: Path, tmp_pixi_workspace: Path) -> N
             "some-arg",
         ],
         ExitCode.FAILURE,
-        stderr_contains="no value provided for argument 'required_arg'",
+        stderr_contains="No value provided for argument 'required_arg'",
     )
 
 
diff --git a/tests/integration_rust/task_tests.rs b/tests/integration_rust/task_tests.rs
index 8b05204b56..3d476d8e93 100644
--- a/tests/integration_rust/task_tests.rs
+++ b/tests/integration_rust/task_tests.rs
@@ -73,10 +73,10 @@ pub async fn add_command_types() {
     assert!(matches!(task2, Task::Execute(cmd) if matches!(cmd.cmd, CmdArgs::Single(_))));
     assert!(matches!(task2, Task::Execute(cmd) if !cmd.depends_on.is_empty()));
 
-    assert_eq!(task.as_single_command().as_deref(), Some("echo hello"));
+    assert_eq!(task.as_single_command().unwrap().to_string(), "echo hello");
     assert_eq!(
-        task2.as_single_command().as_deref(),
-        Some("\"echo hello\" \"echo bonjour\"")
+        task2.as_single_command().unwrap().to_string(),
+        "\"echo hello\" \"echo bonjour\""
     );
 
     // Create an alias

From da6200fde691ae82a5da3d220ea2d54035964b26 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Fri, 11 Apr 2025 19:45:09 -0400
Subject: [PATCH 04/39] update cli docs

---
 pixi_docs/Cargo.lock | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pixi_docs/Cargo.lock b/pixi_docs/Cargo.lock
index 8af37846e9..ef8d46bbae 100644
--- a/pixi_docs/Cargo.lock
+++ b/pixi_docs/Cargo.lock
@@ -4469,6 +4469,7 @@ dependencies = [
 name = "pixi_manifest"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "console",
  "dunce",
  "fancy_display",
@@ -4476,6 +4477,8 @@ dependencies = [
  "indexmap 2.9.0",
  "itertools 0.14.0",
  "miette 7.5.0",
+ "minijinja",
+ "once_cell",
  "pathdiff",
  "pep440_rs",
  "pep508_rs",

From 87351881cb47bb9885c301caf5d02c2847d0ee60 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Fri, 11 Apr 2025 23:15:14 -0400
Subject: [PATCH 05/39] fix the tests

---
 ...rkspace__tests__target_specific_tasks.snap |  8 +-
 .../pixi_manifest/src/manifests/workspace.rs  |  6 +-
 crates/pixi_manifest/src/task.rs              | 21 ++---
 src/cli/task.rs                               |  5 +-
 src/task/executable_task.rs                   | 90 ++++++++++---------
 src/task/task_graph.rs                        | 15 ++--
 src/task/task_hash.rs                         |  2 +-
 src/workspace/environment.rs                  |  2 +
 ...space__tests__target_specific_tasks-2.snap |  6 +-
 ...space__tests__target_specific_tasks-3.snap |  6 +-
 ...rkspace__tests__target_specific_tasks.snap |  6 +-
 tests/integration_rust/task_tests.rs          |  7 +-
 12 files changed, 99 insertions(+), 75 deletions(-)

diff --git a/crates/pixi_manifest/src/manifests/snapshots/pixi_manifest__manifests__workspace__tests__target_specific_tasks.snap b/crates/pixi_manifest/src/manifests/snapshots/pixi_manifest__manifests__workspace__tests__target_specific_tasks.snap
index 00f184498f..f231d0b7d1 100644
--- a/crates/pixi_manifest/src/manifests/snapshots/pixi_manifest__manifests__workspace__tests__target_specific_tasks.snap
+++ b/crates/pixi_manifest/src/manifests/snapshots/pixi_manifest__manifests__workspace__tests__target_specific_tasks.snap
@@ -1,7 +1,7 @@
 ---
 source: crates/pixi_manifest/src/manifests/workspace.rs
-expression: "manifest.default_feature().targets.iter().flat_map(|(target, selector)|\n{\n    let selector_name =\n    selector.map_or_else(|| String::from(\"default\"), ToString::to_string);\n    target.tasks.iter().filter_map(move |(name, task)|\n    {\n        Some(format!(\"{}/{} = {}\", &selector_name, name.as_str(),\n        task.as_single_command()?))\n    })\n}).join(\"\\n\")"
+expression: "manifest.default_feature().targets.iter().flat_map(|(target, selector)|\n{\n    let selector_name =\n    selector.map_or_else(|| String::from(\"default\"), ToString::to_string);\n    target.tasks.iter().map(move |(name, task)|\n    {\n        format!(\"{}/{} = {:?}\", &selector_name, name.as_str(),\n        task.as_single_command().ok())\n    })\n}).join(\"\\n\")"
 ---
-default/test = test multi
-win-64/test = test win
-linux-64/test = test linux
+default/test = Some("test multi")
+win-64/test = Some("test win")
+linux-64/test = Some("test linux")
diff --git a/crates/pixi_manifest/src/manifests/workspace.rs b/crates/pixi_manifest/src/manifests/workspace.rs
index 07ee8ae3de..25f8a91dd2 100644
--- a/crates/pixi_manifest/src/manifests/workspace.rs
+++ b/crates/pixi_manifest/src/manifests/workspace.rs
@@ -1219,7 +1219,10 @@ start = "python -m flask run --port=5050"
                         "{}/{} = {:?}",
                         &selector_name,
                         name.as_str(),
-                        task.as_single_command().ok()
+                        task.as_single_command()
+                            .ok()
+                            .flatten()
+                            .map(|c| c.to_string())
                     )
                 })
             })
@@ -2400,6 +2403,7 @@ platforms = ["linux-64", "win-64"]
                 .get(&"warmup".into())
                 .unwrap()
                 .as_single_command()
+                .unwrap()
                 .unwrap(),
             "python warmup.py"
         );
diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 3dfffe3e0c..46d512ef40 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -157,19 +157,16 @@ impl Task {
     }
 
     /// Returns the command to execute as a single string.
-    pub fn as_single_command(&self) -> Result<Cow<str>, TaskStringError> {
+    pub fn as_single_command(&self) -> Result<Option<Cow<str>>, TaskStringError> {
         let args = self.get_args();
         match self {
             Task::Plain(str) => match str.render(args) {
-                Ok(rendered) => Ok(Cow::Owned(rendered)),
+                Ok(rendered) => Ok(Some(Cow::Owned(rendered))),
                 Err(e) => Err(e),
             },
             Task::Custom(custom) => custom.cmd.as_single(args),
             Task::Execute(exe) => exe.cmd.as_single(args),
-            Task::Alias(_) => Err(TaskStringError {
-                source: anyhow::anyhow!("Alias tasks cannot be executed directly"),
-                task: self.to_string(),
-            }),
+            Task::Alias(_) => Ok(None),
         }
     }
 
@@ -449,16 +446,16 @@ impl CmdArgs {
     pub fn as_single(
         &self,
         argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<Cow<str>, TaskStringError> {
+    ) -> Result<Option<Cow<str>>, TaskStringError> {
         match self {
-            CmdArgs::Single(cmd) => Ok(Cow::Owned(cmd.render(argsmap)?)),
+            CmdArgs::Single(cmd) => Ok(Some(Cow::Owned(cmd.render(argsmap)?))),
             CmdArgs::Multiple(args) => {
                 let mut rendered_args = Vec::new();
                 for arg in args {
                     let rendered = arg.render(argsmap)?;
                     rendered_args.push(quote(&rendered).to_string());
                 }
-                Ok(Cow::Owned(rendered_args.join(" ")))
+                Ok(Some(Cow::Owned(rendered_args.join(" "))))
             }
         }
     }
@@ -467,9 +464,9 @@ impl CmdArgs {
     pub fn into_single(
         self,
         argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<String, TaskStringError> {
+    ) -> Result<Option<String>, TaskStringError> {
         match self {
-            CmdArgs::Single(cmd) => cmd.render(argsmap),
+            CmdArgs::Single(cmd) => cmd.render(argsmap).map(Some),
             CmdArgs::Multiple(args) => {
                 let rendered_args = args
                     .iter()
@@ -480,7 +477,7 @@ impl CmdArgs {
                         })
                     })
                     .collect::<Result<Vec<_>, _>>()?;
-                Ok(rendered_args.join(" "))
+                Ok(Some(rendered_args.join(" ")))
             }
         }
     }
diff --git a/src/cli/task.rs b/src/cli/task.rs
index 95235ca0c8..c8062ad0b7 100644
--- a/src/cli/task.rs
+++ b/src/cli/task.rs
@@ -564,7 +564,10 @@ pub struct TaskInfo {
 impl From<&Task> for TaskInfo {
     fn from(task: &Task) -> Self {
         TaskInfo {
-            cmd: task.as_single_command().map(|cmd| cmd.to_string()).ok(),
+            cmd: task
+                .as_single_command()
+                .ok()
+                .and_then(|cmd| cmd.map(|c| c.to_string())),
             description: task.description().map(|desc| desc.to_string()),
             depends_on: task.depends_on().to_vec(),
             cwd: task.working_directory().map(PathBuf::from),
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index 6892421e75..bfbcfd34f0 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -178,27 +178,30 @@ impl<'p> ExecutableTask<'p> {
     }
 
     /// Returns the task as script
-    fn as_script(&self) -> Result<String, ShellParsingError> {
+    fn as_script(&self) -> Result<Option<String>, ShellParsingError> {
         // Convert the task into an executable string
         let task = self.task.as_single_command()?;
+        if let Some(task) = task {
+            // Get the export specific environment variables
+            let export = get_export_specific_task_env(self.task.as_ref());
+
+            // Append the command line arguments verbatim
+            let cli_args = self
+                .additional_args
+                .iter()
+                .format_with(" ", |arg, f| f(&format_args!("'{}'", arg)));
+
+            // Skip the export if it's empty, to avoid newlines
+            let full_script = if export.is_empty() {
+                format!("{} {}", task, cli_args)
+            } else {
+                format!("{}\n{} {}", export, task, cli_args)
+            };
 
-        // Get the export specific environment variables
-        let export = get_export_specific_task_env(self.task.as_ref());
-
-        // Append the command line arguments verbatim
-        let cli_args = self
-            .additional_args
-            .iter()
-            .format_with(" ", |arg, f| f(&format_args!("'{}'", arg)));
-
-        // Skip the export if it's empty, to avoid newlines
-        let full_script = if export.is_empty() {
-            format!("{task} {cli_args}")
+            Ok(Some(full_script))
         } else {
-            format!("{export}\n{task} {cli_args}")
-        };
-
-        Ok(full_script)
+            Ok(None)
+        }
     }
 
     /// Returns a [`SequentialList`] which can be executed by deno task shell.
@@ -211,18 +214,23 @@ impl<'p> ExecutableTask<'p> {
             script: e.task().to_string(),
             error: e,
         })?;
-        tracing::debug!("Parsing shell script: {}", full_script);
-
-        // Parse the shell command
-        deno_task_shell::parser::parse(full_script.trim())
-            .map_err(|e| FailedToParseShellScript {
-                script: full_script.clone(),
-                error: ShellParsingError::ParseError {
-                    source: e,
-                    task: full_script,
-                },
-            })
-            .map(Some)
+
+        if let Some(full_script) = full_script {
+            tracing::debug!("Parsing shell script: {}", full_script);
+
+            // Parse the shell command
+            deno_task_shell::parser::parse(full_script.trim())
+                .map_err(|e| FailedToParseShellScript {
+                    script: full_script.to_string(),
+                    error: ShellParsingError::ParseError {
+                        source: e,
+                        task: full_script.to_string(),
+                    },
+                })
+                .map(Some)
+        } else {
+            Ok(None)
+        }
     }
 
     /// Returns the working directory for this task.
@@ -248,15 +256,18 @@ impl<'p> ExecutableTask<'p> {
     ///
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
-    pub(crate) fn full_command(&self) -> Result<String, anyhow::Error> {
-        let mut cmd = self.task.as_single_command()?.to_string();
+    pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
+        let original_cmd = self.task.as_single_command()?.map(|c| c.into_owned());
 
-        if !self.additional_args.is_empty() {
-            cmd.push(' ');
-            cmd.push_str(&self.additional_args.join(" "));
+        if let Some(mut cmd) = original_cmd {
+            if !self.additional_args.is_empty() {
+                cmd.push(' ');
+                cmd.push_str(&self.additional_args.join(" "));
+            }
+            Ok(Some(cmd))
+        } else {
+            Ok(None)
         }
-
-        Ok(cmd)
     }
 
     /// Returns an object that implements [`Display`] which outputs the command
@@ -380,10 +391,7 @@ impl Display for ExecutableTaskConsoleDisplay<'_, '_> {
                     f,
                     "{}",
                     consts::TASK_STYLE
-                        .apply_to(match std::convert::AsRef::<str>::as_ref(&command) {
-                            "" => "<alias>",
-                            cmd => cmd,
-                        })
+                        .apply_to(command.as_deref().unwrap_or("<alias>"))
                         .bold()
                 )?;
                 if !self.task.additional_args.is_empty() {
@@ -532,7 +540,7 @@ mod tests {
             additional_args: vec![],
         };
 
-        let script = executable_task.as_script().unwrap();
+        let script = executable_task.as_script().unwrap().unwrap();
         assert_eq!(script, "export \"FOO=bar\";\n\ntest ");
     }
 
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index cd43268579..0bb37cb29a 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -70,7 +70,7 @@ impl fmt::Display for TaskNode<'_> {
             "task: {}, environment: {}, command: `{}`, additional arguments: `{}`, depends-on: `{}`",
             self.name.clone().unwrap_or("CUSTOM COMMAND".into()),
             self.run_environment.name(),
-            self.task.as_single_command().unwrap_or(Cow::Owned("".to_string())),
+            self.task.as_single_command().map_or(String::from(""), |r| r.map_or(String::from(""), |c| c.to_string())),
             self.format_additional_args(),
             self.dependencies
                 .iter()
@@ -89,7 +89,7 @@ impl TaskNode<'_> {
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
     #[cfg(test)]
-    pub(crate) fn full_command(&self) -> Result<String, anyhow::Error> {
+    pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
         let mut cmd = self.task.as_single_command()?;
 
         if let Some(additional_args) = &self.additional_args {
@@ -97,16 +97,17 @@ impl TaskNode<'_> {
                 // Pass each additional argument varbatim by wrapping it in single quotes
                 let formatted_args = format!(" {}", self.format_additional_args());
                 cmd = match cmd {
-                    Cow::Borrowed(s) => Cow::Owned(format!("{}{}", s, formatted_args)),
-                    Cow::Owned(mut s) => {
+                    Some(Cow::Borrowed(s)) => Some(Cow::Owned(format!("{}{}", s, formatted_args))),
+                    Some(Cow::Owned(mut s)) => {
                         s.push_str(&formatted_args);
-                        Cow::Owned(s)
+                        Some(Cow::Owned(s))
                     }
+                    None => None,
                 };
             }
         }
 
-        Ok(cmd.into_owned())
+        Ok(cmd.map(|c| c.into_owned()))
     }
 
     /// Format the additional arguments passed to this command
@@ -468,7 +469,7 @@ mod test {
             .topological_order()
             .into_iter()
             .map(|task| &graph[task])
-            .filter_map(|task| task.full_command().ok())
+            .filter_map(|task| task.full_command().ok().flatten())
             .collect()
     }
 
diff --git a/src/task/task_hash.rs b/src/task/task_hash.rs
index d8f74cf4d7..90f6db8cca 100644
--- a/src/task/task_hash.rs
+++ b/src/task/task_hash.rs
@@ -118,7 +118,7 @@ impl TaskHash {
         }
 
         Ok(Some(Self {
-            command: task.full_command().ok(),
+            command: task.full_command().ok().flatten(),
             outputs: output_hashes,
             inputs: input_hashes,
             // Skipping environment variables used for caching the task
diff --git a/src/workspace/environment.rs b/src/workspace/environment.rs
index da948af9d5..9417cafb7b 100644
--- a/src/workspace/environment.rs
+++ b/src/workspace/environment.rs
@@ -434,6 +434,7 @@ mod tests {
             .task(&"foo".into(), None)
             .unwrap()
             .as_single_command()
+            .unwrap()
             .unwrap();
 
         assert_eq!(task, "echo default");
@@ -443,6 +444,7 @@ mod tests {
             .task(&"foo".into(), Some(Platform::Linux64))
             .unwrap()
             .as_single_command()
+            .unwrap()
             .unwrap();
 
         assert_eq!(task_osx, "echo linux");
diff --git a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap
index 4419dc1a1e..4c1c253292 100644
--- a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap
+++ b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap
@@ -1,11 +1,13 @@
 ---
 source: src/workspace/mod.rs
-expression: "workspace.workspace.value.tasks(Some(Platform::Win64),\n&FeatureName::Default).unwrap()"
+expression: "workspace.workspace.value.tasks(Some(Platform::Win64),\n&FeatureName::DEFAULT).unwrap()"
 ---
 {
     TaskName(
         "test",
     ): Plain(
-        "test win",
+        TaskString {
+            _inner: "test win",
+        },
     ),
 }
diff --git a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap
index 82bff5d8d1..82acb9f59d 100644
--- a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap
+++ b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap
@@ -1,11 +1,13 @@
 ---
 source: src/workspace/mod.rs
-expression: "workspace.workspace.value.tasks(Some(Platform::Linux64),\n&FeatureName::Default).unwrap()"
+expression: "workspace.workspace.value.tasks(Some(Platform::Linux64),\n&FeatureName::DEFAULT).unwrap()"
 ---
 {
     TaskName(
         "test",
     ): Plain(
-        "test linux",
+        TaskString {
+            _inner: "test linux",
+        },
     ),
 }
diff --git a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap
index 9f0862e2fd..16605c3e82 100644
--- a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap
+++ b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap
@@ -1,11 +1,13 @@
 ---
 source: src/workspace/mod.rs
-expression: "workspace.workspace.value.tasks(Some(Platform::Osx64),\n&FeatureName::Default).unwrap()"
+expression: "workspace.workspace.value.tasks(Some(Platform::Osx64),\n&FeatureName::DEFAULT).unwrap()"
 ---
 {
     TaskName(
         "test",
     ): Plain(
-        "test multi",
+        TaskString {
+            _inner: "test multi",
+        },
     ),
 }
diff --git a/tests/integration_rust/task_tests.rs b/tests/integration_rust/task_tests.rs
index 3d476d8e93..d59bcf1b1a 100644
--- a/tests/integration_rust/task_tests.rs
+++ b/tests/integration_rust/task_tests.rs
@@ -73,9 +73,12 @@ pub async fn add_command_types() {
     assert!(matches!(task2, Task::Execute(cmd) if matches!(cmd.cmd, CmdArgs::Single(_))));
     assert!(matches!(task2, Task::Execute(cmd) if !cmd.depends_on.is_empty()));
 
-    assert_eq!(task.as_single_command().unwrap().to_string(), "echo hello");
     assert_eq!(
-        task2.as_single_command().unwrap().to_string(),
+        task.as_single_command().unwrap().unwrap().to_string(),
+        "echo hello"
+    );
+    assert_eq!(
+        task2.as_single_command().unwrap().unwrap().to_string(),
         "\"echo hello\" \"echo bonjour\""
     );
 

From 97108a11c55849603bbcac82e8666c2c53e6e831 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Mon, 14 Apr 2025 15:22:27 +0200
Subject: [PATCH 06/39] TaskNode Display improvement

---
 src/task/task_graph.rs | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index 0bb37cb29a..29b79a0231 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -67,11 +67,21 @@ impl fmt::Display for TaskNode<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "task: {}, environment: {}, command: `{}`, additional arguments: `{}`, depends-on: `{}`",
-            self.name.clone().unwrap_or("CUSTOM COMMAND".into()),
-            self.run_environment.name(),
-            self.task.as_single_command().map_or(String::from(""), |r| r.map_or(String::from(""), |c| c.to_string())),
-            self.format_additional_args(),
+            "task: {}",
+            self.name.clone().unwrap_or("CUSTOM COMMAND".into())
+        )?;
+        write!(f, ", environment: {}", self.run_environment.name())?;
+        if let Ok(Some(command)) = self.task.as_single_command() {
+            write!(f, "command: `{command}`,",)?;
+        }
+        write!(
+            f,
+            ", additional arguments: `{}`",
+            self.format_additional_args()
+        )?;
+        write!(
+            f,
+            ", depends-on: `{}`",
             self.dependencies
                 .iter()
                 .map(|id| format!("{:?}", id.task_id()))

From f5cd54cc3508b9ae545dfdb717cab5d71d968fbe Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Mon, 14 Apr 2025 16:42:59 +0200
Subject: [PATCH 07/39] Small improvement

---
 crates/pixi_manifest/src/toml/task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/pixi_manifest/src/toml/task.rs b/crates/pixi_manifest/src/toml/task.rs
index 5a28d80afc..0ead86d846 100644
--- a/crates/pixi_manifest/src/toml/task.rs
+++ b/crates/pixi_manifest/src/toml/task.rs
@@ -184,7 +184,7 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
             let args = th.optional::<Vec<TaskArg>>("args");
 
             let mut have_default = false;
-            for arg in args.as_ref().unwrap_or(&vec![]) {
+            for arg in args.iter().flat_map(|a| a.iter()) {
                 if arg.default.is_some() {
                     have_default = true;
                 }

From f42fa2d2b20f073cdc1a8e9877f5e88f57f7a153 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Mon, 14 Apr 2025 16:45:55 +0200
Subject: [PATCH 08/39] Small step in the right direction

---
 crates/pixi_manifest/src/task.rs |  2 +-
 src/task/executable_task.rs      | 14 +++++++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 46d512ef40..e521af7a64 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -306,7 +306,7 @@ pub struct Execute {
     pub clean_env: bool,
 
     /// The arguments to pass to the task
-    pub args: Option<IndexMap<String, Option<String>>>,
+    pub args: Option<Vec<TaskArg>>,
 }
 
 impl From<Execute> for Task {
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index bfbcfd34f0..bc3370ea2c 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -118,7 +118,17 @@ pub struct ExecutableTask<'p> {
     pub name: Option<TaskName>,
     pub task: Cow<'p, Task>,
     pub run_environment: Environment<'p>,
-    pub additional_args: Vec<String>,
+    pub args: Args,
+}
+
+enum Args {
+    FreeFormArgs(Vec<String>),
+    TypedArgs(Vec<TypedArgs>),
+}
+
+struct TypedArg {
+    name: String,
+    value: String,
 }
 
 impl<'p> ExecutableTask<'p> {
@@ -130,6 +140,7 @@ impl<'p> ExecutableTask<'p> {
             // Create a task with updated arguments
             match &node.task {
                 Cow::Borrowed(task) => {
+                    // TODO: remove `with_updated_args`
                     Cow::Owned(task.with_updated_args(&argument_values).unwrap_or_else(|| {
                         tracing::warn!(
                             "Failed to update arguments for task {}",
@@ -139,6 +150,7 @@ impl<'p> ExecutableTask<'p> {
                     }))
                 }
                 Cow::Owned(task) => {
+                    // TODO: remove `with_updated_args`
                     Cow::Owned(task.with_updated_args(&argument_values).unwrap_or_else(|| {
                         tracing::warn!(
                             "Failed to update arguments for task {}",

From 3765f33ca6a6303ac141d62a063e075fec2d3f90 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Mon, 14 Apr 2025 23:57:00 -0400
Subject: [PATCH 09/39] Refactor task argument handling and error types

---
 .../pixi_manifest/src/manifests/workspace.rs  |  10 +-
 crates/pixi_manifest/src/task.rs              | 186 ++++------
 crates/pixi_manifest/src/toml/task.rs         |   6 +-
 src/cli/task.rs                               |   7 +-
 src/task/executable_task.rs                   |  64 +---
 src/task/task_graph.rs                        |  70 ++--
 src/workspace/environment.rs                  |   4 +-
 trampoline/Cargo.lock                         | 323 ++++++++++++------
 8 files changed, 344 insertions(+), 326 deletions(-)

diff --git a/crates/pixi_manifest/src/manifests/workspace.rs b/crates/pixi_manifest/src/manifests/workspace.rs
index 25f8a91dd2..36645829cd 100644
--- a/crates/pixi_manifest/src/manifests/workspace.rs
+++ b/crates/pixi_manifest/src/manifests/workspace.rs
@@ -16,6 +16,7 @@ use crate::{
     manifests::document::ManifestDocument,
     pypi::PyPiPackageName,
     solve_group::SolveGroups,
+    task::Args,
     to_options,
     toml::{ExternalWorkspaceProperties, FromTomlStr, TomlManifest},
     utils::WithSourceCode,
@@ -209,6 +210,7 @@ impl WorkspaceManifestMut<'_> {
         task: Task,
         platform: Option<Platform>,
         feature_name: &FeatureName,
+        args: Option<&Args>,
     ) -> miette::Result<()> {
         // Check if the task already exists
         if let Ok(tasks) = self.workspace.tasks(platform, feature_name) {
@@ -1219,7 +1221,7 @@ start = "python -m flask run --port=5050"
                         "{}/{} = {:?}",
                         &selector_name,
                         name.as_str(),
-                        task.as_single_command()
+                        task.as_single_command(None)
                             .ok()
                             .flatten()
                             .map(|c| c.to_string())
@@ -2402,7 +2404,7 @@ platforms = ["linux-64", "win-64"]
                 .tasks
                 .get(&"warmup".into())
                 .unwrap()
-                .as_single_command()
+                .as_single_command(None)
                 .unwrap()
                 .unwrap(),
             "python warmup.py"
@@ -2452,6 +2454,7 @@ test = "test initial"
                 Task::Plain("echo default".into()),
                 None,
                 &FeatureName::DEFAULT,
+                None,
             )
             .unwrap();
         manifest
@@ -2460,6 +2463,7 @@ test = "test initial"
                 Task::Plain("echo target_linux".into()),
                 Some(Platform::Linux64),
                 &FeatureName::DEFAULT,
+                None,
             )
             .unwrap();
         manifest
@@ -2468,6 +2472,7 @@ test = "test initial"
                 Task::Plain("echo feature_test".into()),
                 None,
                 &FeatureName::from("test"),
+                None,
             )
             .unwrap();
         manifest
@@ -2476,6 +2481,7 @@ test = "test initial"
                 Task::Plain("echo feature_test_target_linux".into()),
                 Some(Platform::Linux64),
                 &FeatureName::from("test"),
+                None,
             )
             .unwrap();
         assert_snapshot!(manifest.document.to_string());
diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index e521af7a64..efbfad759b 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -9,9 +9,7 @@ use std::{
 use crate::workspace::JINJA_ENV;
 use indexmap::IndexMap;
 use itertools::Itertools;
-use miette::Diagnostic;
 use serde::Serialize;
-use thiserror::Error;
 use toml_edit::{Array, Item, Table, Value};
 
 use crate::EnvironmentName;
@@ -112,13 +110,10 @@ impl Task {
     }
 
     /// If this task is a plain task, returns the task string
-    pub fn as_plain(&self) -> Result<String, TaskStringError> {
+    pub fn as_plain(&self) -> Result<String, anyhow::Error> {
         match self {
             Task::Plain(str) => str.render(None),
-            _ => Err(TaskStringError {
-                source: anyhow::anyhow!("Task is not a plain task"),
-                task: self.to_string(),
-            }),
+            _ => Err(anyhow::anyhow!("Task is not a plain task")),
         }
     }
 
@@ -157,15 +152,17 @@ impl Task {
     }
 
     /// Returns the command to execute as a single string.
-    pub fn as_single_command(&self) -> Result<Option<Cow<str>>, TaskStringError> {
-        let args = self.get_args();
+    pub fn as_single_command(
+        &self,
+        args_values: Option<&Args>,
+    ) -> Result<Option<Cow<str>>, anyhow::Error> {
         match self {
-            Task::Plain(str) => match str.render(args) {
+            Task::Plain(str) => match str.render(args_values) {
                 Ok(rendered) => Ok(Some(Cow::Owned(rendered))),
                 Err(e) => Err(e),
             },
-            Task::Custom(custom) => custom.cmd.as_single(args),
-            Task::Execute(exe) => exe.cmd.as_single(args),
+            Task::Custom(custom) => custom.cmd.as_single(args_values),
+            Task::Execute(exe) => exe.cmd.as_single(args_values),
             Task::Alias(_) => Ok(None),
         }
     }
@@ -234,43 +231,12 @@ impl Task {
     }
 
     /// Returns the arguments of the task.
-    pub fn get_args(&self) -> Option<&IndexMap<String, Option<String>>> {
+    pub fn get_args(&self) -> Option<&Vec<TaskArg>> {
         match self {
             Task::Execute(exe) => exe.args.as_ref(),
             _ => None,
         }
     }
-
-    /// Creates a new task with updated arguments from the provided values.
-    /// Returns None if the task doesn't support arguments.
-    pub fn with_updated_args(&self, arg_values: &[String]) -> Option<Self> {
-        match self {
-            Task::Execute(exe) => {
-                if arg_values.len() > exe.args.as_ref().map_or(0, |args| args.len()) {
-                    tracing::warn!("Task has more arguments than provided values");
-                    return None;
-                }
-
-                if let Some(args_map) = &exe.args {
-                    let mut new_args = args_map.clone();
-                    for ((arg_name, _), value) in args_map.iter().zip(arg_values.iter()) {
-                        if let Some(arg_value) = new_args.get_mut(arg_name) {
-                            *arg_value = Some(value.clone());
-                        }
-                    }
-
-                    // Create a new Execute with the updated args
-                    let mut new_exe = (**exe).clone();
-                    new_exe.args = Some(new_args);
-
-                    Some(Task::Execute(Box::new(new_exe)))
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    }
 }
 
 /// A command script executes a single command from the environment
@@ -354,72 +320,50 @@ impl From<Custom> for Task {
     }
 }
 
-/// Represents an error while rendering a task string
-#[derive(Debug, Error, Diagnostic)]
-pub struct TaskStringError {
-    #[source]
-    pub source: anyhow::Error,
-    pub task: String,
-}
-
-impl std::fmt::Display for TaskStringError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.task)
-    }
-}
-
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct TaskString {
-    _inner: String,
-}
+pub struct TaskString(String);
 
 impl From<&str> for TaskString {
     fn from(value: &str) -> Self {
-        TaskString {
-            _inner: value.to_string(),
-        }
+        TaskString(value.to_string())
     }
 }
 
 impl From<String> for TaskString {
     fn from(value: String) -> Self {
-        TaskString { _inner: value }
+        TaskString(value)
     }
 }
 
+/// Represents the arguments to pass to a task
+#[derive(Debug, Clone)]
+pub enum Args {
+    FreeFormArgs(Vec<String>),
+    TypedArgs(Vec<TypedArg>),
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct TypedArg {
+    name: String,
+    value: String,
+}
+
 impl TaskString {
     // TODO: enable feature for serialize
     // TODO: check if the Minijinja Value can be used.
-    pub fn render(
-        &self,
-        argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<String, TaskStringError> {
-        if let Some(argsmap) = argsmap {
-            // If any of the values are None, we should error
-            if argsmap.values().any(|v| v.is_none()) {
-                let undefined_arg = argsmap
-                    .iter()
-                    .find_map(|(k, v)| if v.is_none() { Some(k) } else { None })
-                    .unwrap();
-                return Err(TaskStringError {
-                    source: anyhow::anyhow!("No value provided for argument '{}'", undefined_arg),
-                    task: self._inner.clone(),
-                });
-            }
+    pub fn render(&self, args: Option<&Args>) -> Result<String, anyhow::Error> {
+        // If any of the values are None, we should error
+        if let Some(Args::TypedArgs(args)) = args {
             return JINJA_ENV
-                .render_str(&self._inner, argsmap)
-                .map_err(|e| TaskStringError {
-                    source: e.into(),
-                    task: self._inner.clone(),
-                });
+                .render_str(&self.0, args)
+                .map_err(|e| anyhow::anyhow!("{}", e));
         }
 
-        JINJA_ENV
-            .render_str(&self._inner, ())
-            .map_err(|e| TaskStringError {
-                source: e.into(),
-                task: self._inner.clone(),
-            })
+        Ok(self.0.clone())
+    }
+
+    pub fn source(&self) -> &str {
+        &self.0
     }
 }
 
@@ -443,16 +387,13 @@ impl From<TaskString> for CmdArgs {
 
 impl CmdArgs {
     /// Returns a single string representation of the command arguments.
-    pub fn as_single(
-        &self,
-        argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<Option<Cow<str>>, TaskStringError> {
+    pub fn as_single(&self, args_values: Option<&Args>) -> Result<Option<Cow<str>>, anyhow::Error> {
         match self {
-            CmdArgs::Single(cmd) => Ok(Some(Cow::Owned(cmd.render(argsmap)?))),
+            CmdArgs::Single(cmd) => Ok(Some(Cow::Owned(cmd.render(args_values)?))),
             CmdArgs::Multiple(args) => {
                 let mut rendered_args = Vec::new();
                 for arg in args {
-                    let rendered = arg.render(argsmap)?;
+                    let rendered = arg.render(args_values)?;
                     rendered_args.push(quote(&rendered).to_string());
                 }
                 Ok(Some(Cow::Owned(rendered_args.join(" "))))
@@ -461,17 +402,14 @@ impl CmdArgs {
     }
 
     /// Returns a single string representation of the command arguments.
-    pub fn into_single(
-        self,
-        argsmap: Option<&IndexMap<String, Option<String>>>,
-    ) -> Result<Option<String>, TaskStringError> {
+    pub fn into_single(self, args_values: Option<&Args>) -> Result<Option<String>, anyhow::Error> {
         match self {
-            CmdArgs::Single(cmd) => cmd.render(argsmap).map(Some),
+            CmdArgs::Single(cmd) => cmd.render(args_values).map(Some),
             CmdArgs::Multiple(args) => {
                 let rendered_args = args
                     .iter()
                     .map(|arg| {
-                        Ok(match arg.render(argsmap) {
+                        Ok(match arg.render(args_values) {
                             Ok(rendered) => quote(&rendered).to_string(),
                             Err(e) => return Err(e),
                         })
@@ -496,19 +434,13 @@ impl Display for Task {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Task::Plain(cmd) => {
-                write!(f, "{}", cmd.render(None).unwrap())?;
+                write!(f, "{}", cmd.source())?;
             }
             Task::Execute(execute) => match &execute.cmd {
-                CmdArgs::Single(cmd) => {
-                    write!(f, "{}", cmd.render(execute.args.as_ref()).unwrap())?
+                CmdArgs::Single(cmd) => write!(f, "{}", cmd.source())?,
+                CmdArgs::Multiple(mult) => {
+                    write!(f, "{}", mult.iter().map(|arg| arg.source()).join(" "))?
                 }
-                CmdArgs::Multiple(mult) => write!(
-                    f,
-                    "{}",
-                    mult.iter()
-                        .map(|arg| arg.render(execute.args.as_ref()).unwrap())
-                        .join(" ")
-                )?,
             },
             _ => {}
         };
@@ -562,29 +494,25 @@ pub fn quote(in_str: &str) -> Cow<str> {
 impl From<Task> for Item {
     fn from(value: Task) -> Self {
         match value {
-            Task::Plain(str) => Item::Value(str.render(None).unwrap().into()),
+            Task::Plain(str) => Item::Value(str.source().into()),
             Task::Execute(process) => {
                 let mut table = Table::new().into_inline_table();
-                match process.cmd {
+                match &process.cmd {
                     CmdArgs::Single(cmd_str) => {
-                        table.insert("cmd", cmd_str.render(process.args.as_ref()).unwrap().into());
+                        table.insert("cmd", cmd_str.source().into());
                     }
                     CmdArgs::Multiple(cmd_strs) => {
                         table.insert(
                             "cmd",
-                            Value::Array(Array::from_iter(
-                                cmd_strs
-                                    .iter()
-                                    .map(|arg| arg.render(process.args.as_ref()).unwrap()),
-                            )),
+                            Value::Array(Array::from_iter(cmd_strs.iter().map(|arg| arg.source()))),
                         );
                     }
                 }
                 if !process.depends_on.is_empty() {
                     table.insert(
                         "depends-on",
-                        Value::Array(Array::from_iter(process.depends_on.into_iter().map(
-                            |dep| match &dep.args {
+                        Value::Array(Array::from_iter(process.depends_on.iter().map(|dep| {
+                            match &dep.args {
                                 Some(args) if !args.is_empty() => {
                                     let mut table = Table::new().into_inline_table();
                                     table.insert("task", dep.task_name.to_string().into());
@@ -597,17 +525,17 @@ impl From<Task> for Item {
                                     Value::InlineTable(table)
                                 }
                                 _ => Value::from(dep.task_name.to_string()),
-                            },
-                        ))),
+                            }
+                        }))),
                     );
                 }
-                if let Some(cwd) = process.cwd {
+                if let Some(cwd) = &process.cwd {
                     table.insert("cwd", cwd.to_string_lossy().to_string().into());
                 }
-                if let Some(env) = process.env {
+                if let Some(env) = &process.env {
                     table.insert("env", Value::InlineTable(env.into_iter().collect()));
                 }
-                if let Some(description) = process.description {
+                if let Some(description) = &process.description {
                     table.insert("description", description.into());
                 }
                 Item::Value(Value::InlineTable(table))
diff --git a/crates/pixi_manifest/src/toml/task.rs b/crates/pixi_manifest/src/toml/task.rs
index 0ead86d846..f1d75a9881 100644
--- a/crates/pixi_manifest/src/toml/task.rs
+++ b/crates/pixi_manifest/src/toml/task.rs
@@ -208,11 +208,7 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
                 env,
                 description,
                 clean_env,
-                args: args.map(|args| {
-                    args.into_iter()
-                        .map(|arg| (arg.name, arg.default))
-                        .collect()
-                }),
+                args,
             }))
         } else {
             let depends_on = depends_on(&mut th).unwrap_or_default();
diff --git a/src/cli/task.rs b/src/cli/task.rs
index c8062ad0b7..9e7818311a 100644
--- a/src/cli/task.rs
+++ b/src/cli/task.rs
@@ -216,11 +216,7 @@ impl From<AddArgs> for Task {
                 env,
                 description,
                 clean_env,
-                args: args.map(|args| {
-                    args.into_iter()
-                        .map(|arg| (arg.name, arg.default))
-                        .collect()
-                }),
+                args,
             }))
         }
     }
@@ -388,6 +384,7 @@ async fn alias_task(mut workspace: WorkspaceMut, args: AliasArgs) -> miette::Res
         task.clone(),
         args.platform,
         &FeatureName::DEFAULT,
+        None,
     )?;
     workspace.save().await.into_diagnostic()?;
     eprintln!(
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index bc3370ea2c..39ffdefc96 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -12,7 +12,7 @@ use fs_err::tokio as tokio_fs;
 use itertools::Itertools;
 use miette::{Context, Diagnostic};
 use pixi_consts::consts;
-use pixi_manifest::{task::TaskStringError, Task, TaskName};
+use pixi_manifest::{task::Args, Task, TaskName};
 use pixi_progress::await_in_progress;
 use rattler_lock::LockFile;
 use thiserror::Error;
@@ -96,14 +96,6 @@ pub enum CacheUpdateError {
     Serialization(#[from] serde_json::Error),
 }
 
-impl From<TaskStringError> for ShellParsingError {
-    fn from(value: TaskStringError) -> Self {
-        ShellParsingError::ArgumentReplacement {
-            source: value.source,
-            task: value.task,
-        }
-    }
-}
 pub enum CanSkip {
     Yes,
     No(Option<TaskHash>),
@@ -121,56 +113,17 @@ pub struct ExecutableTask<'p> {
     pub args: Args,
 }
 
-enum Args {
-    FreeFormArgs(Vec<String>),
-    TypedArgs(Vec<TypedArgs>),
-}
-
-struct TypedArg {
-    name: String,
-    value: String,
-}
-
 impl<'p> ExecutableTask<'p> {
     /// Constructs a new executable task from a task graph node.
     pub fn from_task_graph(task_graph: &TaskGraph<'p>, task_id: TaskId) -> Self {
         let node = &task_graph[task_id];
 
-        let task = if let Some(argument_values) = node.arguments_values.clone() {
-            // Create a task with updated arguments
-            match &node.task {
-                Cow::Borrowed(task) => {
-                    // TODO: remove `with_updated_args`
-                    Cow::Owned(task.with_updated_args(&argument_values).unwrap_or_else(|| {
-                        tracing::warn!(
-                            "Failed to update arguments for task {}",
-                            node.name.as_ref().unwrap_or(&"default".into())
-                        );
-                        (*task).clone()
-                    }))
-                }
-                Cow::Owned(task) => {
-                    // TODO: remove `with_updated_args`
-                    Cow::Owned(task.with_updated_args(&argument_values).unwrap_or_else(|| {
-                        tracing::warn!(
-                            "Failed to update arguments for task {}",
-                            node.name.as_ref().unwrap_or(&"default".into())
-                        );
-                        task.clone()
-                    }))
-                }
-            }
-        } else {
-            // Clone the existing task
-            node.task.clone()
-        };
-
         Self {
             workspace: task_graph.project(),
             name: node.name.clone(),
-            task,
+            task: node.task.clone(),
             run_environment: node.run_environment.clone(),
-            additional_args: node.additional_args.clone().unwrap_or_default(),
+            args: node.args.clone(),
         }
     }
 
@@ -192,7 +145,7 @@ impl<'p> ExecutableTask<'p> {
     /// Returns the task as script
     fn as_script(&self) -> Result<Option<String>, ShellParsingError> {
         // Convert the task into an executable string
-        let task = self.task.as_single_command()?;
+        let task = self.task.as_single_command(Some(&self.args))?;
         if let Some(task) = task {
             // Get the export specific environment variables
             let export = get_export_specific_task_env(self.task.as_ref());
@@ -269,7 +222,10 @@ impl<'p> ExecutableTask<'p> {
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
     pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
-        let original_cmd = self.task.as_single_command()?.map(|c| c.into_owned());
+        let original_cmd = self
+            .task
+            .as_single_command(Some(&self.args))?
+            .map(|c| c.into_owned());
 
         if let Some(mut cmd) = original_cmd {
             if !self.additional_args.is_empty() {
@@ -397,7 +353,7 @@ struct ExecutableTaskConsoleDisplay<'p, 't> {
 
 impl Display for ExecutableTaskConsoleDisplay<'_, '_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self.task.task.as_single_command() {
+        match self.task.task.as_single_command(Some(&self.task.args)) {
             Ok(command) => {
                 write!(
                     f,
@@ -549,7 +505,7 @@ mod tests {
             name: Some("test".into()),
             task: Cow::Borrowed(task),
             run_environment: workspace.default_environment(),
-            additional_args: vec![],
+            args: vec![],
         };
 
         let script = executable_task.as_script().unwrap().unwrap();
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index 29b79a0231..a653db0027 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -9,7 +9,7 @@ use std::{
 use itertools::Itertools;
 use miette::Diagnostic;
 use pixi_manifest::{
-    task::{CmdArgs, Custom, Dependency},
+    task::{Args, CmdArgs, Custom, Dependency},
     EnvironmentName, Task, TaskName,
 };
 use thiserror::Error;
@@ -54,10 +54,7 @@ pub struct TaskNode<'p> {
 
     /// Additional arguments to pass to the command. These arguments are passed
     /// verbatim, e.g. they will not be interpreted by deno.
-    pub additional_args: Option<Vec<String>>,
-
-    /// The arguments to pass to the dependencies.
-    pub arguments_values: Option<Vec<String>>,
+    pub args: Option<Args>,
 
     /// The id's of the task that this task depends on.
     pub dependencies: Vec<GraphDependency>,
@@ -71,7 +68,7 @@ impl fmt::Display for TaskNode<'_> {
             self.name.clone().unwrap_or("CUSTOM COMMAND".into())
         )?;
         write!(f, ", environment: {}", self.run_environment.name())?;
-        if let Ok(Some(command)) = self.task.as_single_command() {
+        if let Ok(Some(command)) = self.task.as_single_command(self.args.as_ref()) {
             write!(f, "command: `{command}`,",)?;
         }
         write!(
@@ -100,9 +97,9 @@ impl TaskNode<'_> {
     /// execute. This is the case for alias only commands.
     #[cfg(test)]
     pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
-        let mut cmd = self.task.as_single_command()?;
+        let mut cmd = self.task.as_single_command(self.args.as_ref())?;
 
-        if let Some(additional_args) = &self.additional_args {
+        if let Some(Args::FreeFormArgs(additional_args)) = &self.args {
             if !additional_args.is_empty() {
                 // Pass each additional argument varbatim by wrapping it in single quotes
                 let formatted_args = format!(" {}", self.format_additional_args());
@@ -205,17 +202,15 @@ impl<'p> TaskGraph<'p> {
 
                     let task_name = args.remove(0);
 
-                    let (additional_args, arguments_values) = if let Some(argument_map) =
-                        task.get_args()
-                    {
+                    let args = if let Some(task_arguments) = task.get_args() {
                         // Check if we don't have more arguments than the task expects
-                        if args.len() > argument_map.len() {
+                        if args.len() > task_arguments.len() {
                             return Err(TaskGraphError::TooManyArguments(task_name.to_string()));
                         }
 
-                        (None, Some(args))
+                        Some(Self::merge_args(&task_name, &task_arguments, &args)?)
                     } else {
-                        (Some(args), None)
+                        Some(Args::FreeFormArgs(args))
                     };
 
                     if skip_deps {
@@ -225,8 +220,7 @@ impl<'p> TaskGraph<'p> {
                                 name: Some(task_name.into()),
                                 task: Cow::Borrowed(task),
                                 run_environment: run_env,
-                                additional_args,
-                                arguments_values,
+                                args,
                                 dependencies: vec![],
                             }],
                         });
@@ -239,8 +233,7 @@ impl<'p> TaskGraph<'p> {
                             name: Some(task_name.into()),
                             task: Cow::Borrowed(task),
                             run_environment: run_env,
-                            additional_args,
-                            arguments_values,
+                            args,
                             dependencies: vec![],
                         },
                     );
@@ -282,8 +275,7 @@ impl<'p> TaskGraph<'p> {
                     .into(),
                 ),
                 run_environment,
-                additional_args: Some(additional_args),
-                arguments_values: None,
+                args: Some(Args::FreeFormArgs(additional_args)),
                 dependencies: vec![],
             },
         )
@@ -370,8 +362,11 @@ impl<'p> TaskGraph<'p> {
                     name: Some(dependency.task_name.clone()),
                     task: Cow::Borrowed(task_dependency),
                     run_environment: task_env,
-                    additional_args: Some(Vec::new()),
-                    arguments_values: dependency.args.clone(),
+                    args: self.merge_args(
+                        &dependency.task_name,
+                        &task_dependency.get_args(),
+                        &dependency.args,
+                    ),
                     dependencies: Vec::new(),
                 });
 
@@ -393,6 +388,34 @@ impl<'p> TaskGraph<'p> {
         Ok(Self { project, nodes })
     }
 
+    pub fn merge_args(
+        task_name: &str,
+        task_arguments: &[TaskArg],
+        arg_values: &[String],
+    ) -> Result<Args, TaskGraphError> {
+        let mut typed_args = Vec::with_capacity(task_arguments.len());
+
+        for (i, arg) in task_arguments.iter().enumerate() {
+            let value = if i < arg_values.len() {
+                arg_values[i].clone()
+            } else if let Some(default) = &arg.default {
+                default.clone()
+            } else {
+                return Err(TaskGraphError::MissingArgument(
+                    arg.name.clone(),
+                    task_name.to_string(),
+                ));
+            };
+
+            typed_args.push(TypedArg {
+                name: arg.name.clone(),
+                value,
+            });
+        }
+
+        Ok(Args::TypedArgs(typed_args))
+    }
+
     /// Returns the topological order of the tasks in the graph.
     ///
     /// The topological order is the order in which the tasks should be executed
@@ -441,6 +464,9 @@ pub enum TaskGraphError {
 
     #[error("task '{0}' received more arguments than expected")]
     TooManyArguments(String),
+
+    #[error("no value provided for argument '{0}' for task '{1}'")]
+    MissingArgument(String, String),
 }
 
 #[cfg(test)]
diff --git a/src/workspace/environment.rs b/src/workspace/environment.rs
index 9417cafb7b..c4f0138b53 100644
--- a/src/workspace/environment.rs
+++ b/src/workspace/environment.rs
@@ -433,7 +433,7 @@ mod tests {
             .default_environment()
             .task(&"foo".into(), None)
             .unwrap()
-            .as_single_command()
+            .as_single_command(None)
             .unwrap()
             .unwrap();
 
@@ -443,7 +443,7 @@ mod tests {
             .default_environment()
             .task(&"foo".into(), Some(Platform::Linux64))
             .unwrap()
-            .as_single_command()
+            .as_single_command(None)
             .unwrap()
             .unwrap();
 
diff --git a/trampoline/Cargo.lock b/trampoline/Cargo.lock
index 7f2080e4b3..e3eae88cbf 100644
--- a/trampoline/Cargo.lock
+++ b/trampoline/Cargo.lock
@@ -347,9 +347,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-s3"
-version = "1.79.0"
+version = "1.82.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f63ba8f5fca32061c7d62d866ef65470edde38d4c5f8a0ebb8ff40a0521e1c"
+checksum = "e6eab2900764411ab01c8e91a76fd11a63b4e12bc3da97d9e14a0ce1343d86d3"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -369,7 +369,7 @@ dependencies = [
  "hex",
  "hmac",
  "http 0.2.12",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 0.4.6",
  "lru",
  "once_cell",
@@ -464,7 +464,7 @@ dependencies = [
  "hex",
  "hmac",
  "http 0.2.12",
- "http 1.2.0",
+ "http 1.3.1",
  "once_cell",
  "p256",
  "percent-encoding",
@@ -553,7 +553,7 @@ dependencies = [
  "bytes-utils",
  "futures-core",
  "http 0.2.12",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 0.4.6",
  "once_cell",
  "percent-encoding",
@@ -591,6 +591,16 @@ dependencies = [
  "aws-smithy-types",
 ]
 
+[[package]]
+name = "aws-smithy-observability"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "445d065e76bc1ef54963db400319f1dd3ebb3e0a74af20f7f7630625b0cc7cc0"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "once_cell",
+]
+
 [[package]]
 name = "aws-smithy-query"
 version = "0.60.7"
@@ -603,19 +613,20 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6328865e36c6fd970094ead6b05efd047d3a80ec5fc3be5e743910da9f2ebf8"
+checksum = "0152749e17ce4d1b47c7747bdfec09dac1ccafdcbc741ebf9daa2a373356730f"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-http 0.62.0",
  "aws-smithy-http-client",
+ "aws-smithy-observability",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
  "fastrand",
  "http 0.2.12",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "once_cell",
@@ -635,7 +646,7 @@ dependencies = [
  "aws-smithy-types",
  "bytes",
  "http 0.2.12",
- "http 1.2.0",
+ "http 1.3.1",
  "pin-project-lite",
  "tokio",
  "tracing",
@@ -653,7 +664,7 @@ dependencies = [
  "bytes-utils",
  "futures-core",
  "http 0.2.12",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "http-body-util",
@@ -1437,9 +1448,9 @@ dependencies = [
 
 [[package]]
 name = "file_url"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f75ca0511313d95b0ca15b916b4532975b31b92ed882ddeaa23cbfca4955f32a"
+checksum = "46ca1565923e8d9bcf962889abeeb2f15d4b73356689ce26ae7dd1f54b928498"
 dependencies = [
  "itertools 0.14.0",
  "percent-encoding",
@@ -1512,14 +1523,14 @@ dependencies = [
 
 [[package]]
 name = "fs4"
-version = "0.12.0"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c29c30684418547d476f0b48e84f4821639119c483b1eccd566c8cd0cd05f521"
+checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"
 dependencies = [
  "fs-err",
- "rustix 0.38.41",
+ "rustix 1.0.2",
  "tokio",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1664,11 +1675,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "r-efi",
  "wasi 0.14.2+wasi-0.2.4",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -1748,7 +1757,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1766,8 +1775,8 @@ dependencies = [
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.2.0",
- "indexmap 2.8.0",
+ "http 1.3.1",
+ "indexmap 2.9.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1878,9 +1887,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f16ca2af56261c99fba8bac40a10251ce8188205a4c448fbb745a2e4daa76fea"
+checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
 dependencies = [
  "bytes",
  "fnv",
@@ -1905,7 +1914,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http 1.2.0",
+ "http 1.3.1",
 ]
 
 [[package]]
@@ -1916,7 +1925,7 @@ checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
 dependencies = [
  "bytes",
  "futures-util",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 1.0.1",
  "pin-project-lite",
 ]
@@ -1927,7 +1936,7 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92baf25cf0b8c9246baecf3a444546360a97b569168fdf92563ee6a47829920c"
 dependencies = [
- "http 1.2.0",
+ "http 1.3.1",
  "http-serde",
  "reqwest",
  "serde",
@@ -1940,7 +1949,7 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f056c8559e3757392c8d091e796416e4649d8e49e88b8d76df6c002f05027fd"
 dependencies = [
- "http 1.2.0",
+ "http 1.3.1",
  "serde",
 ]
 
@@ -1967,9 +1976,9 @@ dependencies = [
 
 [[package]]
 name = "humantime"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+checksum = "9b112acc8b3adf4b107a8ec20977da0273a8c386765a3ec0229bd500a1443f9f"
 
 [[package]]
 name = "hyper"
@@ -2005,7 +2014,7 @@ dependencies = [
  "futures-channel",
  "futures-util",
  "h2 0.4.7",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 1.0.1",
  "httparse",
  "itoa",
@@ -2038,7 +2047,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333"
 dependencies = [
  "futures-util",
- "http 1.2.0",
+ "http 1.3.1",
  "hyper 1.5.1",
  "hyper-util",
  "rustls 0.23.17",
@@ -2059,7 +2068,7 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 1.0.1",
  "hyper 1.5.1",
  "pin-project-lite",
@@ -2250,9 +2259,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
+checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.1",
@@ -2750,9 +2759,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.21.1"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d75b0bedcc4fe52caa0e03d9f1151a323e4aa5e2d78ba3580400cd3c9e2bc4bc"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "openssl-probe"
@@ -2888,7 +2897,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "faee7227064121fcadcd2ff788ea26f0d8f2bd23a0574da11eca23bc935bcc05"
 dependencies = [
  "boxcar",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "itertools 0.13.0",
  "once_cell",
  "pep440_rs",
@@ -3011,6 +3020,7 @@ dependencies = [
  "rattler_conda_types",
  "rattler_networking",
  "rattler_repodata_gateway",
+ "reqwest",
  "serde",
  "serde_ignored",
  "serde_json",
@@ -3093,7 +3103,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42cf17e9a1800f5f396bc67d193dc9411b59012a5876445ef450d449881e1016"
 dependencies = [
  "base64 0.22.1",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "quick-xml 0.32.0",
  "serde",
  "time",
@@ -3315,9 +3325,9 @@ dependencies = [
 
 [[package]]
 name = "rattler"
-version = "0.33.3"
+version = "0.33.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f2f6a77d473028c29adf77cbc29d651d6566ca551bad3434e2314d992c6c1f9"
+checksum = "b2e7bfacc5f5ff3517d984b5e2f2df3eea46e8309685cb7cdff39d62f7b2bee2"
 dependencies = [
  "anyhow",
  "digest",
@@ -3325,7 +3335,7 @@ dependencies = [
  "fs-err",
  "futures",
  "humantime",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "itertools 0.14.0",
  "memchr",
  "memmap2",
@@ -3356,9 +3366,9 @@ dependencies = [
 
 [[package]]
 name = "rattler_cache"
-version = "0.3.15"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f84f8ac550603c11d8c681e83c441c0565a29907c40583114b78fc3e31f72bb"
+checksum = "fd2ad44802bc15f7196f0898ff52729aab52338203ddbdff5212146f45aa2a67"
 dependencies = [
  "anyhow",
  "dashmap",
@@ -3388,18 +3398,19 @@ dependencies = [
 
 [[package]]
 name = "rattler_conda_types"
-version = "0.31.5"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea41e41b171d7185f57c4fa0e19ef145c96604ba151479ec070f928325dbe1a"
+checksum = "21c2ed99f2fc8044499c63c65db265f6ec3e0333cdf15bb442d5063187449d51"
 dependencies = [
  "chrono",
+ "core-foundation 0.10.0",
  "dirs",
  "file_url",
  "fs-err",
  "fxhash",
  "glob",
  "hex",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "itertools 0.14.0",
  "lazy-regex",
  "nom",
@@ -3427,9 +3438,9 @@ dependencies = [
 
 [[package]]
 name = "rattler_digest"
-version = "1.0.8"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d81b39557a833c5820f4c373f2b36147672e0c02f44a63387186d1f6f1f240f3"
+checksum = "34751b3e9c9755379281d1b49b9335648a4686c434ce77b5376323980d38e1b8"
 dependencies = [
  "blake2",
  "digest",
@@ -3440,13 +3451,14 @@ dependencies = [
  "serde_with",
  "sha2",
  "tokio",
+ "url",
 ]
 
 [[package]]
 name = "rattler_macros"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52efa676b94d13ff3888074a8eb662e0a603ddddd5697cedc58b21de5f478cfb"
+checksum = "7c9b25725cedeef8dee22c41dee138daf76ebd70da50fe210aa5e50288036816"
 dependencies = [
  "quote",
  "syn",
@@ -3454,9 +3466,9 @@ dependencies = [
 
 [[package]]
 name = "rattler_menuinst"
-version = "0.2.5"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd9d126c14a5f5a50027c9f05992e7caf2122acb7ce528b9009ee92d475dd329"
+checksum = "eb3eedb82b5366136093acb1bafc4839f3f122c64889a358cbe6e50fc8c573b0"
 dependencies = [
  "chrono",
  "configparser",
@@ -3478,15 +3490,15 @@ dependencies = [
  "tracing",
  "unicode-normalization",
  "which",
- "windows",
+ "windows 0.60.0",
  "windows-registry 0.5.0",
 ]
 
 [[package]]
 name = "rattler_networking"
-version = "0.22.10"
+version = "0.22.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bb7aa16bcfa0f53ddbf580c58e43bd8ad7fd8a643c767c365ebf033734d4cd1"
+checksum = "cfe0171ee4c22e335ade0cb926e83cdf08a5dda5eaf26fc21fa9948beb65c764"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3495,10 +3507,10 @@ dependencies = [
  "base64 0.22.1",
  "dirs",
  "fs-err",
- "getrandom 0.3.2",
+ "getrandom 0.2.15",
  "google-cloud-auth",
  "google-cloud-token",
- "http 1.2.0",
+ "http 1.3.1",
  "itertools 0.14.0",
  "keyring",
  "netrc-rs",
@@ -3515,9 +3527,9 @@ dependencies = [
 
 [[package]]
 name = "rattler_package_streaming"
-version = "0.22.34"
+version = "0.22.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d55a377f9b969915695c7aa994740ca157221f6a63d03812404e8d393d81e517"
+checksum = "11879ff84195638459a15f0bb4c0d167f58ecd497d2df00df46c6cf81c0f2bb7"
 dependencies = [
  "bzip2",
  "chrono",
@@ -3543,11 +3555,22 @@ dependencies = [
  "zstd",
 ]
 
+[[package]]
+name = "rattler_pty"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1ba454a7e23bfe50c09abdb3164e26f98b326a04c104389c41e300918b219f"
+dependencies = [
+ "libc",
+ "nix",
+ "signal-hook",
+]
+
 [[package]]
 name = "rattler_redaction"
-version = "0.1.8"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fb481bc7af5d6564f120307bc4481efb4e55c8502424acec3409a4e5d61ef12"
+checksum = "a9d46116e48405681feb0c0c9938ecb6751825eb9bde353069e516784ca983e9"
 dependencies = [
  "reqwest",
  "reqwest-middleware",
@@ -3556,9 +3579,9 @@ dependencies = [
 
 [[package]]
 name = "rattler_repodata_gateway"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba15cb481b9d065194160fddff2fd21d15cac723622a1acddc8fae6b65ce0c7c"
+checksum = "1e25d367f6ff1d83cf925ccacfcf7805f94030f96de6858992db37edb3c5a638"
 dependencies = [
  "anyhow",
  "async-compression",
@@ -3575,7 +3598,7 @@ dependencies = [
  "fs-err",
  "futures",
  "hex",
- "http 1.2.0",
+ "http 1.3.1",
  "http-cache-semantics",
  "humansize",
  "humantime",
@@ -3613,15 +3636,17 @@ dependencies = [
 
 [[package]]
 name = "rattler_shell"
-version = "0.22.24"
+version = "0.22.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c25e56d8c1b003bae96de82c498d550ddea9677825ad52a4d1ececf3ef33613"
+checksum = "bdf546ea648c95cfeb27d8eedb6d592c8dec050d2dc9fb9af5be4ffe13759d7f"
 dependencies = [
+ "anyhow",
  "enum_dispatch",
  "fs-err",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "itertools 0.14.0",
  "rattler_conda_types",
+ "rattler_pty",
  "serde_json",
  "shlex",
  "tempfile",
@@ -3700,14 +3725,14 @@ dependencies = [
 
 [[package]]
 name = "reflink-copy"
-version = "0.1.25"
+version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b86038e146b9a61557e1a2e58cdf2eddc0b46ce141b55541b1c1b9f3189d618"
+checksum = "78c81d000a2c524133cc00d2f92f019d399e57906c3b7119271a2495354fe895"
 dependencies = [
  "cfg-if",
  "libc",
  "rustix 1.0.2",
- "windows",
+ "windows 0.61.1",
 ]
 
 [[package]]
@@ -3747,9 +3772,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "reqwest"
-version = "0.12.14"
+version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "989e327e510263980e231de548a33e63d34962d29ae61b467389a1a09627a254"
+checksum = "d19c46a6fdd48bc4dab94b6103fccc55d34c67cc0ad04653aad4ea2a07cd7bbb"
 dependencies = [
  "async-compression",
  "base64 0.22.1",
@@ -3758,7 +3783,7 @@ dependencies = [
  "futures-core",
  "futures-util",
  "h2 0.4.7",
- "http 1.2.0",
+ "http 1.3.1",
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.5.1",
@@ -3796,13 +3821,13 @@ dependencies = [
 
 [[package]]
 name = "reqwest-middleware"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64e8975513bd9a7a43aad01030e79b3498e05db14e9d945df6483e8cf9b8c4c4"
+checksum = "57f17d28a6e6acfe1733fe24bcd30774d13bffa4b8a22535b4c8c98423088d4e"
 dependencies = [
  "anyhow",
  "async-trait",
- "http 1.2.0",
+ "http 1.3.1",
  "reqwest",
  "serde",
  "thiserror 1.0.69",
@@ -3819,7 +3844,7 @@ dependencies = [
  "async-trait",
  "futures",
  "getrandom 0.2.15",
- "http 1.2.0",
+ "http 1.3.1",
  "hyper 1.5.1",
  "parking_lot 0.11.2",
  "reqwest",
@@ -4197,7 +4222,7 @@ version = "1.0.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
 dependencies = [
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "itoa",
  "memchr",
  "ryu",
@@ -4246,7 +4271,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "serde",
  "serde_derive",
  "serde_json",
@@ -4272,7 +4297,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "itoa",
  "ryu",
  "serde",
@@ -4316,6 +4341,16 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "signal-hook"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.2"
@@ -4400,9 +4435,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
 dependencies = [
  "serde",
 ]
@@ -4540,9 +4575,9 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488960f40a3fd53d72c2a29a58722561dee8afdd175bd88e3db4677d7b2ba600"
+checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
 dependencies = [
  "fastrand",
  "getrandom 0.3.2",
@@ -4659,9 +4694,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.44.1"
+version = "1.44.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f382da615b842244d4b8738c82ed1275e6c5dd90c459a30941cd07080b06c91a"
+checksum = "e6b88822cbe49de4185e3a4cbf8321dd487cf5fe0c5c65695fef6346371e9c48"
 dependencies = [
  "backtrace",
  "bytes",
@@ -4669,6 +4704,7 @@ dependencies = [
  "mio",
  "parking_lot 0.12.3",
  "pin-project-lite",
+ "signal-hook-registry",
  "socket2",
  "tokio-macros",
  "windows-sys 0.52.0",
@@ -4708,9 +4744,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.13"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
+checksum = "6b9590b93e6fcc1739458317cccd391ad3955e2bde8913edf6f95f9e65a8f034"
 dependencies = [
  "bytes",
  "futures-core",
@@ -4734,7 +4770,7 @@ version = "0.22.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "17b4795ff5edd201c7cd6dca065ae59972ce77d1b80fa0a84d94950ece7d1474"
 dependencies = [
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -5195,11 +5231,24 @@ version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ddf874e74c7a99773e62b1c671427abf01a425e77c3d3fb9fb1e4883ea934529"
 dependencies = [
- "windows-collections",
+ "windows-collections 0.1.1",
  "windows-core 0.60.1",
- "windows-future",
+ "windows-future 0.1.1",
+ "windows-link",
+ "windows-numerics 0.1.1",
+]
+
+[[package]]
+name = "windows"
+version = "0.61.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
+dependencies = [
+ "windows-collections 0.2.0",
+ "windows-core 0.61.0",
+ "windows-future 0.2.0",
  "windows-link",
- "windows-numerics",
+ "windows-numerics 0.2.0",
 ]
 
 [[package]]
@@ -5211,6 +5260,15 @@ dependencies = [
  "windows-core 0.60.1",
 ]
 
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.0",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.52.0"
@@ -5226,11 +5284,24 @@ version = "0.60.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca21a92a9cae9bf4ccae5cf8368dce0837100ddf6e6d57936749e85f152f6247"
 dependencies = [
- "windows-implement",
+ "windows-implement 0.59.0",
  "windows-interface",
  "windows-link",
  "windows-result",
- "windows-strings",
+ "windows-strings 0.3.1",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
+dependencies = [
+ "windows-implement 0.60.0",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings 0.4.0",
 ]
 
 [[package]]
@@ -5243,6 +5314,16 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-future"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a1d6bbefcb7b60acd19828e1bc965da6fcf18a7e39490c5f8be71e54a19ba32"
+dependencies = [
+ "windows-core 0.61.0",
+ "windows-link",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.59.0"
@@ -5254,11 +5335,22 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-interface"
-version = "0.59.0"
+version = "0.59.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb26fd936d991781ea39e87c3a27285081e3c0da5ca0fcbc02d368cc6f52ff01"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5267,9 +5359,9 @@ dependencies = [
 
 [[package]]
 name = "windows-link"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dccfd733ce2b1753b03b6d3c65edf020262ea35e20ccdf3e288043e6dd620e3"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
 name = "windows-numerics"
@@ -5281,6 +5373,16 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.0",
+ "windows-link",
+]
+
 [[package]]
 name = "windows-registry"
 version = "0.4.0"
@@ -5288,7 +5390,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4286ad90ddb45071efd1a66dfa43eb02dd0dfbae1545ad6cc3c51cf34d7e8ba3"
 dependencies = [
  "windows-result",
- "windows-strings",
+ "windows-strings 0.3.1",
  "windows-targets 0.53.0",
 ]
 
@@ -5300,14 +5402,14 @@ checksum = "6c44a98275e31bfd112bb06ba96c8ab13c03383a3753fdddd715406a1824c7e0"
 dependencies = [
  "windows-link",
  "windows-result",
- "windows-strings",
+ "windows-strings 0.3.1",
 ]
 
 [[package]]
 name = "windows-result"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06374efe858fab7e4f881500e6e86ec8bc28f9462c47e5a9941a0142ad86b189"
+checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
 dependencies = [
  "windows-link",
 ]
@@ -5321,6 +5423,15 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -5708,18 +5819,16 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "2.4.1"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938cc23ac49778ac8340e366ddc422b2227ea176edb447e23fc0627608dddadd"
+checksum = "1dcb24d0152526ae49b9b96c1dcf71850ca1e0b882e4e28ed898a93c41334744"
 dependencies = [
  "arbitrary",
  "crc32fast",
  "crossbeam-utils",
- "displaydoc",
  "flate2",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "memchr",
- "thiserror 2.0.12",
  "time",
  "zopfli",
 ]

From d2f1e6c3ee5c3afe52c4a37e143c79b7b52a0bf0 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Tue, 15 Apr 2025 15:19:55 -0400
Subject: [PATCH 10/39] finish the desing

---
 .../pixi_manifest/src/manifests/workspace.rs  |  6 --
 crates/pixi_manifest/src/task.rs              | 37 ++++++++----
 src/cli/task.rs                               |  3 +-
 src/task/executable_task.rs                   | 52 +++++++++++------
 src/task/task_graph.rs                        | 58 ++++++++++++-------
 tests/integration_rust/task_tests.rs          |  4 +-
 6 files changed, 101 insertions(+), 59 deletions(-)

diff --git a/crates/pixi_manifest/src/manifests/workspace.rs b/crates/pixi_manifest/src/manifests/workspace.rs
index 36645829cd..9aae6189c3 100644
--- a/crates/pixi_manifest/src/manifests/workspace.rs
+++ b/crates/pixi_manifest/src/manifests/workspace.rs
@@ -16,7 +16,6 @@ use crate::{
     manifests::document::ManifestDocument,
     pypi::PyPiPackageName,
     solve_group::SolveGroups,
-    task::Args,
     to_options,
     toml::{ExternalWorkspaceProperties, FromTomlStr, TomlManifest},
     utils::WithSourceCode,
@@ -210,7 +209,6 @@ impl WorkspaceManifestMut<'_> {
         task: Task,
         platform: Option<Platform>,
         feature_name: &FeatureName,
-        args: Option<&Args>,
     ) -> miette::Result<()> {
         // Check if the task already exists
         if let Ok(tasks) = self.workspace.tasks(platform, feature_name) {
@@ -2454,7 +2452,6 @@ test = "test initial"
                 Task::Plain("echo default".into()),
                 None,
                 &FeatureName::DEFAULT,
-                None,
             )
             .unwrap();
         manifest
@@ -2463,7 +2460,6 @@ test = "test initial"
                 Task::Plain("echo target_linux".into()),
                 Some(Platform::Linux64),
                 &FeatureName::DEFAULT,
-                None,
             )
             .unwrap();
         manifest
@@ -2472,7 +2468,6 @@ test = "test initial"
                 Task::Plain("echo feature_test".into()),
                 None,
                 &FeatureName::from("test"),
-                None,
             )
             .unwrap();
         manifest
@@ -2481,7 +2476,6 @@ test = "test initial"
                 Task::Plain("echo feature_test_target_linux".into()),
                 Some(Platform::Linux64),
                 &FeatureName::from("test"),
-                None,
             )
             .unwrap();
         assert_snapshot!(manifest.document.to_string());
diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index efbfad759b..3aa7cd03de 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -154,7 +154,7 @@ impl Task {
     /// Returns the command to execute as a single string.
     pub fn as_single_command(
         &self,
-        args_values: Option<&Args>,
+        args_values: Option<&ArgValues>,
     ) -> Result<Option<Cow<str>>, anyhow::Error> {
         match self {
             Task::Plain(str) => match str.render(args_values) {
@@ -281,7 +281,7 @@ impl From<Execute> for Task {
     }
 }
 
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq, Serialize)]
 pub struct TaskArg {
     /// The name of the argument
     pub name: String,
@@ -336,24 +336,33 @@ impl From<String> for TaskString {
 }
 
 /// Represents the arguments to pass to a task
-#[derive(Debug, Clone)]
-pub enum Args {
+#[derive(Debug, Clone, Serialize, Eq, PartialEq, Hash)]
+pub enum ArgValues {
     FreeFormArgs(Vec<String>),
     TypedArgs(Vec<TypedArg>),
 }
 
-#[derive(Debug, Clone, Serialize)]
+impl ArgValues {
+    pub fn is_empty(&self) -> bool {
+        match self {
+            ArgValues::FreeFormArgs(args) => args.is_empty(),
+            ArgValues::TypedArgs(args) => args.is_empty(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Eq, PartialEq, Hash)]
 pub struct TypedArg {
-    name: String,
-    value: String,
+    pub name: String,
+    pub value: String,
 }
 
 impl TaskString {
     // TODO: enable feature for serialize
     // TODO: check if the Minijinja Value can be used.
-    pub fn render(&self, args: Option<&Args>) -> Result<String, anyhow::Error> {
+    pub fn render(&self, args: Option<&ArgValues>) -> Result<String, anyhow::Error> {
         // If any of the values are None, we should error
-        if let Some(Args::TypedArgs(args)) = args {
+        if let Some(ArgValues::TypedArgs(args)) = args {
             return JINJA_ENV
                 .render_str(&self.0, args)
                 .map_err(|e| anyhow::anyhow!("{}", e));
@@ -387,7 +396,10 @@ impl From<TaskString> for CmdArgs {
 
 impl CmdArgs {
     /// Returns a single string representation of the command arguments.
-    pub fn as_single(&self, args_values: Option<&Args>) -> Result<Option<Cow<str>>, anyhow::Error> {
+    pub fn as_single(
+        &self,
+        args_values: Option<&ArgValues>,
+    ) -> Result<Option<Cow<str>>, anyhow::Error> {
         match self {
             CmdArgs::Single(cmd) => Ok(Some(Cow::Owned(cmd.render(args_values)?))),
             CmdArgs::Multiple(args) => {
@@ -402,7 +414,10 @@ impl CmdArgs {
     }
 
     /// Returns a single string representation of the command arguments.
-    pub fn into_single(self, args_values: Option<&Args>) -> Result<Option<String>, anyhow::Error> {
+    pub fn into_single(
+        self,
+        args_values: Option<&ArgValues>,
+    ) -> Result<Option<String>, anyhow::Error> {
         match self {
             CmdArgs::Single(cmd) => cmd.render(args_values).map(Some),
             CmdArgs::Multiple(args) => {
diff --git a/src/cli/task.rs b/src/cli/task.rs
index 9e7818311a..dd198d8f66 100644
--- a/src/cli/task.rs
+++ b/src/cli/task.rs
@@ -384,7 +384,6 @@ async fn alias_task(mut workspace: WorkspaceMut, args: AliasArgs) -> miette::Res
         task.clone(),
         args.platform,
         &FeatureName::DEFAULT,
-        None,
     )?;
     workspace.save().await.into_diagnostic()?;
     eprintln!(
@@ -562,7 +561,7 @@ impl From<&Task> for TaskInfo {
     fn from(task: &Task) -> Self {
         TaskInfo {
             cmd: task
-                .as_single_command()
+                .as_single_command(None)
                 .ok()
                 .and_then(|cmd| cmd.map(|c| c.to_string())),
             description: task.description().map(|desc| desc.to_string()),
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index 39ffdefc96..b89e572bbf 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -12,7 +12,7 @@ use fs_err::tokio as tokio_fs;
 use itertools::Itertools;
 use miette::{Context, Diagnostic};
 use pixi_consts::consts;
-use pixi_manifest::{task::Args, Task, TaskName};
+use pixi_manifest::{task::ArgValues, Task, TaskName};
 use pixi_progress::await_in_progress;
 use rattler_lock::LockFile;
 use thiserror::Error;
@@ -110,7 +110,7 @@ pub struct ExecutableTask<'p> {
     pub name: Option<TaskName>,
     pub task: Cow<'p, Task>,
     pub run_environment: Environment<'p>,
-    pub args: Args,
+    pub args: ArgValues,
 }
 
 impl<'p> ExecutableTask<'p> {
@@ -123,7 +123,10 @@ impl<'p> ExecutableTask<'p> {
             name: node.name.clone(),
             task: node.task.clone(),
             run_environment: node.run_environment.clone(),
-            args: node.args.clone(),
+            args: node
+                .args
+                .clone()
+                .unwrap_or(ArgValues::FreeFormArgs([].into())),
         }
     }
 
@@ -145,16 +148,25 @@ impl<'p> ExecutableTask<'p> {
     /// Returns the task as script
     fn as_script(&self) -> Result<Option<String>, ShellParsingError> {
         // Convert the task into an executable string
-        let task = self.task.as_single_command(Some(&self.args))?;
+        let task = self.task.as_single_command(Some(&self.args)).map_err(|e| {
+            ShellParsingError::ParseError {
+                source: e,
+                task: self.task.to_string(),
+            }
+        })?;
         if let Some(task) = task {
             // Get the export specific environment variables
             let export = get_export_specific_task_env(self.task.as_ref());
 
             // Append the command line arguments verbatim
-            let cli_args = self
-                .additional_args
-                .iter()
-                .format_with(" ", |arg, f| f(&format_args!("'{}'", arg)));
+            let cli_args = if let ArgValues::FreeFormArgs(additional_args) = &self.args {
+                additional_args
+                    .iter()
+                    .format_with(" ", |arg, f| f(&format_args!("'{}'", arg)))
+                    .to_string()
+            } else {
+                String::new()
+            };
 
             // Skip the export if it's empty, to avoid newlines
             let full_script = if export.is_empty() {
@@ -228,9 +240,11 @@ impl<'p> ExecutableTask<'p> {
             .map(|c| c.into_owned());
 
         if let Some(mut cmd) = original_cmd {
-            if !self.additional_args.is_empty() {
-                cmd.push(' ');
-                cmd.push_str(&self.additional_args.join(" "));
+            if let ArgValues::FreeFormArgs(additional_args) = &self.args {
+                if !additional_args.is_empty() {
+                    cmd.push(' ');
+                    cmd.push_str(&additional_args.join(" "));
+                }
             }
             Ok(Some(cmd))
         } else {
@@ -362,12 +376,14 @@ impl Display for ExecutableTaskConsoleDisplay<'_, '_> {
                         .apply_to(command.as_deref().unwrap_or("<alias>"))
                         .bold()
                 )?;
-                if !self.task.additional_args.is_empty() {
-                    write!(
-                        f,
-                        " {}",
-                        consts::TASK_STYLE.apply_to(self.task.additional_args.iter().format(" "))
-                    )?;
+                if let ArgValues::FreeFormArgs(additional_args) = &self.task.args {
+                    if !additional_args.is_empty() {
+                        write!(
+                            f,
+                            " {}",
+                            consts::TASK_STYLE.apply_to(additional_args.iter().format(" "))
+                        )?;
+                    }
                 }
                 Ok(())
             }
@@ -505,7 +521,7 @@ mod tests {
             name: Some("test".into()),
             task: Cow::Borrowed(task),
             run_environment: workspace.default_environment(),
-            args: vec![],
+            args: ArgValues::FreeFormArgs([].into()),
         };
 
         let script = executable_task.as_script().unwrap().unwrap();
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index a653db0027..5479c1a3c5 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -9,7 +9,7 @@ use std::{
 use itertools::Itertools;
 use miette::Diagnostic;
 use pixi_manifest::{
-    task::{Args, CmdArgs, Custom, Dependency},
+    task::{ArgValues, CmdArgs, Custom, Dependency, TaskArg, TypedArg},
     EnvironmentName, Task, TaskName,
 };
 use thiserror::Error;
@@ -54,7 +54,7 @@ pub struct TaskNode<'p> {
 
     /// Additional arguments to pass to the command. These arguments are passed
     /// verbatim, e.g. they will not be interpreted by deno.
-    pub args: Option<Args>,
+    pub args: Option<ArgValues>,
 
     /// The id's of the task that this task depends on.
     pub dependencies: Vec<GraphDependency>,
@@ -99,7 +99,7 @@ impl TaskNode<'_> {
     pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
         let mut cmd = self.task.as_single_command(self.args.as_ref())?;
 
-        if let Some(Args::FreeFormArgs(additional_args)) = &self.args {
+        if let Some(ArgValues::FreeFormArgs(additional_args)) = &self.args {
             if !additional_args.is_empty() {
                 // Pass each additional argument varbatim by wrapping it in single quotes
                 let formatted_args = format!(" {}", self.format_additional_args());
@@ -119,7 +119,7 @@ impl TaskNode<'_> {
 
     /// Format the additional arguments passed to this command
     fn format_additional_args(&self) -> Box<dyn Display + '_> {
-        if let Some(additional_args) = &self.additional_args {
+        if let Some(ArgValues::FreeFormArgs(additional_args)) = &self.args {
             Box::new(
                 additional_args
                     .iter()
@@ -202,15 +202,19 @@ impl<'p> TaskGraph<'p> {
 
                     let task_name = args.remove(0);
 
-                    let args = if let Some(task_arguments) = task.get_args() {
+                    let arg_values = if let Some(task_arguments) = task.get_args() {
                         // Check if we don't have more arguments than the task expects
                         if args.len() > task_arguments.len() {
                             return Err(TaskGraphError::TooManyArguments(task_name.to_string()));
                         }
 
-                        Some(Self::merge_args(&task_name, &task_arguments, &args)?)
+                        Some(Self::merge_args(
+                            &TaskName::from(task_name.clone()),
+                            &Some(task_arguments),
+                            &Some(&args),
+                        )?)
                     } else {
-                        Some(Args::FreeFormArgs(args))
+                        Some(ArgValues::FreeFormArgs(args.clone()))
                     };
 
                     if skip_deps {
@@ -220,7 +224,7 @@ impl<'p> TaskGraph<'p> {
                                 name: Some(task_name.into()),
                                 task: Cow::Borrowed(task),
                                 run_environment: run_env,
-                                args,
+                                args: arg_values,
                                 dependencies: vec![],
                             }],
                         });
@@ -233,9 +237,10 @@ impl<'p> TaskGraph<'p> {
                             name: Some(task_name.into()),
                             task: Cow::Borrowed(task),
                             run_environment: run_env,
-                            args,
+                            args: arg_values,
                             dependencies: vec![],
                         },
+                        Some(args),
                     );
                 }
             }
@@ -275,9 +280,10 @@ impl<'p> TaskGraph<'p> {
                     .into(),
                 ),
                 run_environment,
-                args: Some(Args::FreeFormArgs(additional_args)),
+                args: Some(ArgValues::FreeFormArgs(additional_args)),
                 dependencies: vec![],
             },
+            None,
         )
     }
 
@@ -286,11 +292,12 @@ impl<'p> TaskGraph<'p> {
         project: &'p Workspace,
         search_environments: &SearchEnvironments<'p, D>,
         root: TaskNode<'p>,
+        root_args: Option<Vec<String>>,
     ) -> Result<Self, TaskGraphError> {
         let mut task_name_with_args_to_node: HashMap<Dependency, TaskId> =
             HashMap::from_iter(root.name.clone().into_iter().map(|name| {
                 (
-                    Dependency::new_without_env(&name.to_string(), root.arguments_values.clone()),
+                    Dependency::new_without_env(&name.to_string(), root_args.clone()),
                     TaskId(0),
                 )
             }));
@@ -362,11 +369,12 @@ impl<'p> TaskGraph<'p> {
                     name: Some(dependency.task_name.clone()),
                     task: Cow::Borrowed(task_dependency),
                     run_environment: task_env,
-                    args: self.merge_args(
+                    args: Self::merge_args(
                         &dependency.task_name,
                         &task_dependency.get_args(),
-                        &dependency.args,
-                    ),
+                        &dependency.args.as_ref(),
+                    )
+                    .ok(),
                     dependencies: Vec::new(),
                 });
 
@@ -388,11 +396,21 @@ impl<'p> TaskGraph<'p> {
         Ok(Self { project, nodes })
     }
 
-    pub fn merge_args(
-        task_name: &str,
-        task_arguments: &[TaskArg],
-        arg_values: &[String],
-    ) -> Result<Args, TaskGraphError> {
+    fn merge_args(
+        task_name: &TaskName,
+        task_arguments: &Option<&Vec<TaskArg>>,
+        arg_values: &Option<&Vec<String>>,
+    ) -> Result<ArgValues, TaskGraphError> {
+        let task_arguments = match task_arguments {
+            Some(args) => args,
+            None => return Ok(ArgValues::FreeFormArgs(Vec::new())),
+        };
+
+        let arg_values = match arg_values {
+            Some(values) => values,
+            None => return Ok(ArgValues::FreeFormArgs(Vec::new())),
+        };
+
         let mut typed_args = Vec::with_capacity(task_arguments.len());
 
         for (i, arg) in task_arguments.iter().enumerate() {
@@ -413,7 +431,7 @@ impl<'p> TaskGraph<'p> {
             });
         }
 
-        Ok(Args::TypedArgs(typed_args))
+        Ok(ArgValues::TypedArgs(typed_args))
     }
 
     /// Returns the topological order of the tasks in the graph.
diff --git a/tests/integration_rust/task_tests.rs b/tests/integration_rust/task_tests.rs
index d59bcf1b1a..2e461f4a2e 100644
--- a/tests/integration_rust/task_tests.rs
+++ b/tests/integration_rust/task_tests.rs
@@ -74,11 +74,11 @@ pub async fn add_command_types() {
     assert!(matches!(task2, Task::Execute(cmd) if !cmd.depends_on.is_empty()));
 
     assert_eq!(
-        task.as_single_command().unwrap().unwrap().to_string(),
+        task.as_single_command(None).unwrap().unwrap().to_string(),
         "echo hello"
     );
     assert_eq!(
-        task2.as_single_command().unwrap().unwrap().to_string(),
+        task2.as_single_command(None).unwrap().unwrap().to_string(),
         "\"echo hello\" \"echo bonjour\""
     );
 

From 352029fdac593367083fd56debd7378445376040 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Tue, 15 Apr 2025 16:36:42 -0400
Subject: [PATCH 11/39] fix tests

---
 crates/pixi_manifest/src/task.rs         |  7 ++++++-
 src/task/task_graph.rs                   | 13 ++++++-------
 tests/integration_python/test_run_cli.py |  4 ++--
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 3aa7cd03de..aaec4e3ea7 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -363,8 +363,13 @@ impl TaskString {
     pub fn render(&self, args: Option<&ArgValues>) -> Result<String, anyhow::Error> {
         // If any of the values are None, we should error
         if let Some(ArgValues::TypedArgs(args)) = args {
+            let context: indexmap::IndexMap<String, String> = args
+                .iter()
+                .map(|arg| (arg.name.clone(), arg.value.clone()))
+                .collect();
+                
             return JINJA_ENV
-                .render_str(&self.0, args)
+                .render_str(&self.0, &context)
                 .map_err(|e| anyhow::anyhow!("{}", e));
         }
 
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index 5479c1a3c5..56d819d900 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -369,12 +369,11 @@ impl<'p> TaskGraph<'p> {
                     name: Some(dependency.task_name.clone()),
                     task: Cow::Borrowed(task_dependency),
                     run_environment: task_env,
-                    args: Self::merge_args(
+                    args: Some(Self::merge_args(
                         &dependency.task_name,
                         &task_dependency.get_args(),
                         &dependency.args.as_ref(),
-                    )
-                    .ok(),
+                    )?),
                     dependencies: Vec::new(),
                 });
 
@@ -402,13 +401,13 @@ impl<'p> TaskGraph<'p> {
         arg_values: &Option<&Vec<String>>,
     ) -> Result<ArgValues, TaskGraphError> {
         let task_arguments = match task_arguments {
-            Some(args) => args,
-            None => return Ok(ArgValues::FreeFormArgs(Vec::new())),
+            Some(args) => *args,
+            None => &vec![],
         };
 
         let arg_values = match arg_values {
-            Some(values) => values,
-            None => return Ok(ArgValues::FreeFormArgs(Vec::new())),
+            Some(values) => *values,
+            None => &vec![],
         };
 
         let mut typed_args = Vec::with_capacity(task_arguments.len());
diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index 999fd0299c..bdc1a45635 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -564,7 +564,7 @@ def test_task_args_all_required(pixi: Path, tmp_pixi_workspace: Path) -> None:
     verify_cli_command(
         [pixi, "run", "--manifest-path", manifest_path, "task_all_required", "val1"],
         ExitCode.FAILURE,
-        stderr_contains="No value provided for argument 'arg2'",
+        stderr_contains="no value provided for argument 'arg2'",
     )
 
 
@@ -751,7 +751,7 @@ def test_depends_on_with_complex_args(pixi: Path, tmp_pixi_workspace: Path) -> N
             "some-arg",
         ],
         ExitCode.FAILURE,
-        stderr_contains="No value provided for argument 'required_arg'",
+        stderr_contains="no value provided for argument 'required_arg'",
     )
 
 

From d1ea78c95b7a18644138c041d76364997cd623b0 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Tue, 15 Apr 2025 16:37:28 -0400
Subject: [PATCH 12/39] fix pre-commit

---
 crates/pixi_manifest/src/task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index aaec4e3ea7..1195dc63fe 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -367,7 +367,7 @@ impl TaskString {
                 .iter()
                 .map(|arg| (arg.name.clone(), arg.value.clone()))
                 .collect();
-                
+
             return JINJA_ENV
                 .render_str(&self.0, &context)
                 .map_err(|e| anyhow::anyhow!("{}", e));

From eb5c70b497ed71599dbd88d6a65fea9d080e752b Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Tue, 15 Apr 2025 21:19:30 -0400
Subject: [PATCH 13/39] Enhance TaskArg deserialization to reject strings
 containing hyphens

---
 crates/pixi_manifest/src/toml/task.rs | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/crates/pixi_manifest/src/toml/task.rs b/crates/pixi_manifest/src/toml/task.rs
index f1d75a9881..5c075585d0 100644
--- a/crates/pixi_manifest/src/toml/task.rs
+++ b/crates/pixi_manifest/src/toml/task.rs
@@ -17,16 +17,32 @@ impl<'de> toml_span::Deserialize<'de> for TaskArg {
     fn deserialize(value: &mut Value<'de>) -> Result<Self, DeserError> {
         let mut th = match value.take() {
             ValueInner::String(str) => {
+                if str.contains('-') {
+                    return Err(expected(
+                        "string without hyphens",
+                        ValueInner::String(str),
+                        value.span,
+                    )
+                    .into());
+                }
                 return Ok(TaskArg {
                     name: str.into_owned(),
                     default: None,
-                })
+                });
             }
             ValueInner::Table(table) => TableHelper::from((table, value.span)),
             inner => return Err(expected("string or table", inner, value.span).into()),
         };
 
         let name = th.required::<String>("arg")?;
+        if name.contains('-') {
+            return Err(expected(
+                "string without hyphens",
+                ValueInner::String(name.into()),
+                value.span,
+            )
+            .into());
+        }
         let default = th.optional::<String>("default");
 
         th.finalize(None)?;

From 07ab61b7bde9fe6bf34c8623c6b253f80ed8a120 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 10:01:31 +0200
Subject: [PATCH 14/39] Small improvements

---
 crates/pixi_manifest/src/task.rs |  6 ++++++
 src/task/executable_task.rs      |  7 ++-----
 src/task/task_graph.rs           | 20 ++++++++++----------
 3 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 1195dc63fe..de2c3a756e 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -351,6 +351,12 @@ impl ArgValues {
     }
 }
 
+impl Default for ArgValues {
+    fn default() -> Self {
+        Self::FreeFormArgs(Vec::new())
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Eq, PartialEq, Hash)]
 pub struct TypedArg {
     pub name: String,
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index b89e572bbf..f7ebea6afc 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -123,10 +123,7 @@ impl<'p> ExecutableTask<'p> {
             name: node.name.clone(),
             task: node.task.clone(),
             run_environment: node.run_environment.clone(),
-            args: node
-                .args
-                .clone()
-                .unwrap_or(ArgValues::FreeFormArgs([].into())),
+            args: node.args.clone().unwrap_or_default(),
         }
     }
 
@@ -521,7 +518,7 @@ mod tests {
             name: Some("test".into()),
             task: Cow::Borrowed(task),
             run_environment: workspace.default_environment(),
-            args: ArgValues::FreeFormArgs([].into()),
+            args: ArgValues::default(),
         };
 
         let script = executable_task.as_script().unwrap().unwrap();
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index 56d819d900..85938f5843 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -210,8 +210,8 @@ impl<'p> TaskGraph<'p> {
 
                         Some(Self::merge_args(
                             &TaskName::from(task_name.clone()),
-                            &Some(task_arguments),
-                            &Some(&args),
+                            Some(task_arguments),
+                            Some(&args),
                         )?)
                     } else {
                         Some(ArgValues::FreeFormArgs(args.clone()))
@@ -371,8 +371,8 @@ impl<'p> TaskGraph<'p> {
                     run_environment: task_env,
                     args: Some(Self::merge_args(
                         &dependency.task_name,
-                        &task_dependency.get_args(),
-                        &dependency.args.as_ref(),
+                        task_dependency.get_args(),
+                        dependency.args.as_ref(),
                     )?),
                     dependencies: Vec::new(),
                 });
@@ -397,17 +397,17 @@ impl<'p> TaskGraph<'p> {
 
     fn merge_args(
         task_name: &TaskName,
-        task_arguments: &Option<&Vec<TaskArg>>,
-        arg_values: &Option<&Vec<String>>,
+        task_arguments: Option<&Vec<TaskArg>>,
+        arg_values: Option<&Vec<String>>,
     ) -> Result<ArgValues, TaskGraphError> {
         let task_arguments = match task_arguments {
-            Some(args) => *args,
-            None => &vec![],
+            Some(args) => args,
+            None => &Vec::new(),
         };
 
         let arg_values = match arg_values {
-            Some(values) => *values,
-            None => &vec![],
+            Some(values) => values,
+            None => &Vec::new(),
         };
 
         let mut typed_args = Vec::with_capacity(task_arguments.len());

From 774a569195361bc3db41b4415080e1f63cf05132 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 10:12:19 +0200
Subject: [PATCH 15/39] Update snapshots

---
 .../pixi__workspace__tests__target_specific_tasks.snap      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap
index 16605c3e82..575fcdadb9 100644
--- a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap
+++ b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks.snap
@@ -6,8 +6,8 @@ expression: "workspace.workspace.value.tasks(Some(Platform::Osx64),\n&FeatureNam
     TaskName(
         "test",
     ): Plain(
-        TaskString {
-            _inner: "test multi",
-        },
+        TaskString(
+            "test multi",
+        ),
     ),
 }

From ed419ae5f8407334039ef8fdf115c8c941cef827 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 14:03:58 +0200
Subject: [PATCH 16/39] Update snapshots

---
 .../pixi__workspace__tests__target_specific_tasks-2.snap    | 6 +++---
 .../pixi__workspace__tests__target_specific_tasks-3.snap    | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap
index 4c1c253292..742ff1b0bf 100644
--- a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap
+++ b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-2.snap
@@ -6,8 +6,8 @@ expression: "workspace.workspace.value.tasks(Some(Platform::Win64),\n&FeatureNam
     TaskName(
         "test",
     ): Plain(
-        TaskString {
-            _inner: "test win",
-        },
+        TaskString(
+            "test win",
+        ),
     ),
 }
diff --git a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap
index 82acb9f59d..573bba5638 100644
--- a/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap
+++ b/src/workspace/snapshots/pixi__workspace__tests__target_specific_tasks-3.snap
@@ -6,8 +6,8 @@ expression: "workspace.workspace.value.tasks(Some(Platform::Linux64),\n&FeatureN
     TaskName(
         "test",
     ): Plain(
-        TaskString {
-            _inner: "test linux",
-        },
+        TaskString(
+            "test linux",
+        ),
     ),
 }

From acab268f40170514903346ba84549d2ae16bbd38 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 15:16:05 +0200
Subject: [PATCH 17/39] Improve error handling

---
 crates/pixi_manifest/src/task.rs      | 29 +++++++++-
 crates/pixi_manifest/src/toml/task.rs | 80 ++++++++-------------------
 src/task/task_graph.rs                |  4 +-
 3 files changed, 52 insertions(+), 61 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index de2c3a756e..c5537250ad 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -281,21 +281,44 @@ impl From<Execute> for Task {
     }
 }
 
+#[derive(Debug, Clone, Eq, Hash, PartialEq, Serialize)]
+pub struct ArgName(String);
+
+impl FromStr for ArgName {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.contains('-') {
+            Err(format!(
+                "{s} is not a valid argument name since it contains the character '-'"
+            ))
+        } else {
+            Ok(ArgName(s.to_string()))
+        }
+    }
+}
+
+impl ArgName {
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
 #[derive(Debug, Clone, Eq, Hash, PartialEq, Serialize)]
 pub struct TaskArg {
     /// The name of the argument
-    pub name: String,
+    pub name: ArgName,
 
     /// The default value of the argument
     pub default: Option<String>,
 }
 
 impl std::str::FromStr for TaskArg {
-    type Err = miette::Error;
+    type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(TaskArg {
-            name: s.to_string(),
+            name: ArgName::from_str(s)?,
             default: None,
         })
     }
diff --git a/crates/pixi_manifest/src/toml/task.rs b/crates/pixi_manifest/src/toml/task.rs
index 5c075585d0..04bcf75f60 100644
--- a/crates/pixi_manifest/src/toml/task.rs
+++ b/crates/pixi_manifest/src/toml/task.rs
@@ -4,11 +4,11 @@ use pixi_toml::{TomlFromStr, TomlIndexMap};
 use toml_span::{
     de_helpers::{expected, TableHelper},
     value::ValueInner,
-    DeserError, Value,
+    DeserError, ErrorKind, Value,
 };
 
 use crate::{
-    task::{Alias, CmdArgs, Dependency, Execute, TaskArg},
+    task::{Alias, ArgName, CmdArgs, Dependency, Execute, TaskArg},
     warning::Deprecation,
     EnvironmentName, Task, TaskName, WithWarnings,
 };
@@ -17,16 +17,15 @@ impl<'de> toml_span::Deserialize<'de> for TaskArg {
     fn deserialize(value: &mut Value<'de>) -> Result<Self, DeserError> {
         let mut th = match value.take() {
             ValueInner::String(str) => {
-                if str.contains('-') {
-                    return Err(expected(
-                        "string without hyphens",
-                        ValueInner::String(str),
-                        value.span,
-                    )
-                    .into());
-                }
+                let name = ArgName::from_str(&str).map_err(|e| {
+                    DeserError::from(toml_span::Error {
+                        kind: ErrorKind::Custom(e.to_string().into()),
+                        span: value.span,
+                        line_info: None,
+                    })
+                })?;
                 return Ok(TaskArg {
-                    name: str.into_owned(),
+                    name,
                     default: None,
                 });
             }
@@ -34,15 +33,7 @@ impl<'de> toml_span::Deserialize<'de> for TaskArg {
             inner => return Err(expected("string or table", inner, value.span).into()),
         };
 
-        let name = th.required::<String>("arg")?;
-        if name.contains('-') {
-            return Err(expected(
-                "string without hyphens",
-                ValueInner::String(name.into()),
-                value.span,
-            )
-            .into());
-        }
+        let name = th.required::<TomlFromStr<ArgName>>("arg")?.into_inner();
         let default = th.optional::<String>("default");
 
         th.finalize(None)?;
@@ -68,16 +59,8 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
                             let name = th.required::<String>("task")?;
                             let args = th.optional::<Vec<String>>("args");
                             let environment = th
-                                .optional::<String>("environment")
-                                .map(|env| EnvironmentName::from_str(&env))
-                                .transpose()
-                                .map_err(|e| {
-                                    DeserError::from(expected(
-                                        "valid environment name",
-                                        ValueInner::String(e.attempted_parse.into()),
-                                        item.span,
-                                    ))
-                                })?;
+                                .optional::<TomlFromStr<EnvironmentName>>("environment")
+                                .map(TomlFromStr::into_inner);
 
                             deps.push(Dependency::new(&name, args, environment));
                         }
@@ -113,16 +96,8 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
                                     let name = th.required::<String>("task")?;
                                     let args = th.optional::<Vec<String>>("args");
                                     let environment = th
-                                        .optional::<String>("environment")
-                                        .map(|env| EnvironmentName::from_str(&env))
-                                        .transpose()
-                                        .map_err(|e| {
-                                            DeserError::from(expected(
-                                                "valid environment name",
-                                                ValueInner::String(e.attempted_parse.into()),
-                                                span,
-                                            ))
-                                        })?;
+                                        .optional::<TomlFromStr<EnvironmentName>>("environment")
+                                        .map(TomlFromStr::into_inner);
 
                                     Ok(Dependency::new(&name, args, environment))
                                 }
@@ -158,16 +133,8 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
                                     let name = th.required::<String>("task")?;
                                     let args = th.optional::<Vec<String>>("args");
                                     let environment = th
-                                        .optional::<String>("environment")
-                                        .map(|env| EnvironmentName::from_str(&env))
-                                        .transpose()
-                                        .map_err(|e| {
-                                            DeserError::from(expected(
-                                                "valid environment name",
-                                                ValueInner::String(e.attempted_parse.into()),
-                                                span,
-                                            ))
-                                        })?;
+                                        .optional::<TomlFromStr<EnvironmentName>>("environment")
+                                        .map(TomlFromStr::into_inner);
                                     // If the creating a new dependency fails, it means the environment name is invalid and exists hence we can safely unwrap the environment
                                     Ok(Dependency::new(&name, args, environment))
                                 }
@@ -205,12 +172,13 @@ impl<'de> toml_span::Deserialize<'de> for TomlTask {
                     have_default = true;
                 }
                 if have_default && arg.default.is_none() {
-                    return Err(expected(
-                        "default value required after previous arguments with defaults",
-                        ValueInner::Table(Default::default()),
-                        value.span,
-                    )
-                    .into());
+                    return Err(DeserError::from(toml_span::Error {
+                        kind: ErrorKind::Custom(
+                            "default value required after previous arguments with defaults".into(),
+                        ),
+                        span: value.span,
+                        line_info: None,
+                    }));
                 }
             }
             th.finalize(None)?;
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index 85938f5843..3f8febbbb8 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -419,13 +419,13 @@ impl<'p> TaskGraph<'p> {
                 default.clone()
             } else {
                 return Err(TaskGraphError::MissingArgument(
-                    arg.name.clone(),
+                    arg.name.as_str().to_owned(),
                     task_name.to_string(),
                 ));
             };
 
             typed_args.push(TypedArg {
-                name: arg.name.clone(),
+                name: arg.name.as_str().to_owned(),
                 value,
             });
         }

From 679d3b72567e519d9c917f4fa4411121513d2b69 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 15:23:10 +0200
Subject: [PATCH 18/39] Adapt error message

---
 tests/integration_python/test_run_cli.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index bdc1a45635..cd917777ca 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -432,7 +432,7 @@ def test_invalid_task_args(pixi: Path, tmp_pixi_workspace: Path) -> None:
             "arg3",
         ],
         ExitCode.FAILURE,
-        stderr_contains="expected default value required after previous arguments with defaults",
+        stderr_contains="default value required after previous arguments with defaults",
     )
 
 

From ca8bc5280928688accd91395bed6568d82489db8 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 16:09:35 +0200
Subject: [PATCH 19/39] Fix another test failure

---
 crates/pixi_manifest/src/task.rs         |  4 +--
 tests/integration_python/test_run_cli.py | 32 ++++++++++++++----------
 2 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index c5537250ad..d685bd7c16 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -290,7 +290,7 @@ impl FromStr for ArgName {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s.contains('-') {
             Err(format!(
-                "{s} is not a valid argument name since it contains the character '-'"
+                "'{s}' is not a valid argument name since it contains the character '-'"
             ))
         } else {
             Ok(ArgName(s.to_string()))
@@ -399,7 +399,7 @@ impl TaskString {
 
             return JINJA_ENV
                 .render_str(&self.0, &context)
-                .map_err(|e| anyhow::anyhow!("{}", e));
+                .map_err(|e| e.into());
         }
 
         Ok(self.0.clone())
diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index cd917777ca..f0ebf61317 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -777,8 +777,8 @@ def test_argument_forwarding(pixi: Path, tmp_pixi_workspace: Path) -> None:
     # Task with defined args should validate them
     manifest_content["tasks"] = {
         "test_single": {
-            "cmd": "echo Python file: {{ python-file }}",
-            "args": ["python-file"],  # This argument is mandatory
+            "cmd": "echo Python file: {{ python_file }}",
+            "args": ["python_file"],  # This argument is mandatory
         }
     }
     manifest_path.write_text(tomli_w.dumps(manifest_content))
@@ -808,34 +808,40 @@ def test_argument_forwarding(pixi: Path, tmp_pixi_workspace: Path) -> None:
     verify_cli_command(
         [pixi, "run", "--manifest-path", manifest_path, "test_single"],
         ExitCode.FAILURE,
-        stderr_contains="no value provided for argument 'python-file'",
+        stderr_contains="no value provided for argument 'python_file'",
     )
 
 
-def test_undefined_arguments_in_command(pixi: Path, tmp_pixi_workspace: Path) -> None:
-    """Test behavior when using undefined arguments in commands."""
+def test_argument_with_dash_errors(pixi: Path, tmp_pixi_workspace: Path) -> None:
     manifest_path = tmp_pixi_workspace.joinpath("pixi.toml")
-    manifest_content = tomli.loads(EMPTY_BOILERPLATE_PROJECT)
 
-    # Command with undefined argument
+    # Simple task with no args defined should just forward arguments
+    manifest_content = tomli.loads(EMPTY_BOILERPLATE_PROJECT)
     manifest_content["tasks"] = {
-        "undefined_arg": {
+        "test_single": {
             "cmd": "echo Python file: {{ python-file }}",
-            # No args defined, but using {{ python-file }} in command
+            "args": ["python-file"],  # This argument is mandatory
         }
     }
     manifest_path.write_text(tomli_w.dumps(manifest_content))
 
+    # This should work - exactly one argument provided as required
     verify_cli_command(
-        [pixi, "run", "--manifest-path", manifest_path, "undefined_arg"],
+        [pixi, "install", "--manifest-path", manifest_path],
         ExitCode.FAILURE,
-        stderr_contains="Failed to replace argument placeholders",
+        stderr_contains="'python-file' is not a valid argument name since it contains the character '-'",
     )
 
+
+def test_undefined_arguments_in_command(pixi: Path, tmp_pixi_workspace: Path) -> None:
+    """Test behavior when using undefined arguments in commands."""
+    manifest_path = tmp_pixi_workspace.joinpath("pixi.toml")
+    manifest_content = tomli.loads(EMPTY_BOILERPLATE_PROJECT)
+
     manifest_content["tasks"] = {
         "mixed_args": {
-            "cmd": "echo Python file: {{ python-file }} with {{ non-existing-argument }}",
-            "args": ["python-file"],
+            "cmd": "echo Python file: {{ python_file }} with {{ non_existing_argument }}",
+            "args": ["python_file"],
         }
     }
     manifest_path.write_text(tomli_w.dumps(manifest_content))

From 35b2db356c2096af2c4a40edb95a3e0c038f16e7 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 16:20:33 +0200
Subject: [PATCH 20/39] Use the correct error type

---
 src/task/executable_task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index 862abe92eb..2a8ea38e3d 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -147,7 +147,7 @@ impl<'p> ExecutableTask<'p> {
     fn as_script(&self) -> Result<Option<String>, ShellParsingError> {
         // Convert the task into an executable string
         let task = self.task.as_single_command(Some(&self.args)).map_err(|e| {
-            ShellParsingError::ParseError {
+            ShellParsingError::ArgumentReplacement {
                 source: e,
                 task: self.task.to_string(),
             }

From 0e444f1ee4310013ed634cc0c1d813778a9103f7 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 16:24:32 +0200
Subject: [PATCH 21/39] Push broken error modification

---
 src/task/executable_task.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index 2a8ea38e3d..78c4aa0d90 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -11,7 +11,7 @@ use deno_task_shell::{
 };
 use fs_err::tokio as tokio_fs;
 use itertools::Itertools;
-use miette::{Context, Diagnostic};
+use miette::{Context, Diagnostic, SourceSpan};
 use pixi_consts::consts;
 use pixi_manifest::{task::ArgValues, Task, TaskName};
 use pixi_progress::await_in_progress;
@@ -31,18 +31,19 @@ use crate::{
 
 #[derive(Debug, Error, Diagnostic)]
 pub enum ShellParsingError {
-    #[error("Failed to parse shell script. Task: '{task}'")]
+    #[error("failed to parse shell script. Task: '{task}'")]
     ParseError {
         #[source]
         source: anyhow::Error,
         task: String,
     },
 
-    #[error("Failed to replace argument placeholders. Task: '{task}'")]
+    #[error("failed to replace argument placeholders")]
     ArgumentReplacement {
-        #[source]
-        source: anyhow::Error,
-        task: String,
+        #[source_code]
+        src: String,
+        #[label = "this part can't be replaced"]
+        err_span: SourceSpan,
     },
 }
 

From 92270e9fcfda10dec1ab9845abebf145d2ada4a4 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Wed, 16 Apr 2025 16:27:35 +0200
Subject: [PATCH 22/39] Enable builtins

---
 crates/pixi_manifest/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/pixi_manifest/Cargo.toml b/crates/pixi_manifest/Cargo.toml
index 8da0649766..cc0227b262 100644
--- a/crates/pixi_manifest/Cargo.toml
+++ b/crates/pixi_manifest/Cargo.toml
@@ -48,7 +48,7 @@ rattler_solve = { workspace = true, optional = true }
 anyhow = "1.0.97"
 console = { workspace = true }
 miette = { workspace = true, features = ["fancy-no-backtrace"] }
-minijinja.workspace = true
+minijinja = { workspace = true, features = ["builtins"] }
 once_cell.workspace = true
 
 [dev-dependencies]

From c08f61b878072afe3abc7a8ed776ea41fbda84f3 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Wed, 16 Apr 2025 16:20:07 -0400
Subject: [PATCH 23/39] Refactor error handling

---
 crates/pixi_manifest/src/task.rs | 54 +++++++++++++++-------
 src/cli/run.rs                   |  1 +
 src/task/executable_task.rs      | 77 +++++++++++---------------------
 src/task/task_graph.rs           |  2 +-
 4 files changed, 67 insertions(+), 67 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index d685bd7c16..62e8608552 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -9,7 +9,9 @@ use std::{
 use crate::workspace::JINJA_ENV;
 use indexmap::IndexMap;
 use itertools::Itertools;
+use miette::{Diagnostic, SourceSpan};
 use serde::Serialize;
+use thiserror::Error;
 use toml_edit::{Array, Item, Table, Value};
 
 use crate::EnvironmentName;
@@ -110,10 +112,13 @@ impl Task {
     }
 
     /// If this task is a plain task, returns the task string
-    pub fn as_plain(&self) -> Result<String, anyhow::Error> {
+    pub fn as_plain(&self) -> Result<String, TaskStringError> {
         match self {
             Task::Plain(str) => str.render(None),
-            _ => Err(anyhow::anyhow!("Task is not a plain task")),
+            _ => Err(TaskStringError {
+                src: "".to_string(),
+                err_span: SourceSpan::new(0.into(), 0),
+            }),
         }
     }
 
@@ -155,7 +160,7 @@ impl Task {
     pub fn as_single_command(
         &self,
         args_values: Option<&ArgValues>,
-    ) -> Result<Option<Cow<str>>, anyhow::Error> {
+    ) -> Result<Option<Cow<str>>, TaskStringError> {
         match self {
             Task::Plain(str) => match str.render(args_values) {
                 Ok(rendered) => Ok(Some(Cow::Owned(rendered))),
@@ -380,6 +385,21 @@ impl Default for ArgValues {
     }
 }
 
+#[derive(Debug, Diagnostic, Error, Clone)]
+#[error("failed to replace argument placeholders")]
+pub struct TaskStringError {
+    #[source_code]
+    src: String,
+    #[label = "this part can't be replaced"]
+    err_span: SourceSpan,
+}
+
+impl TaskStringError {
+    pub fn get_source(&self) -> &str {
+        &self.src
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Eq, PartialEq, Hash)]
 pub struct TypedArg {
     pub name: String,
@@ -389,20 +409,22 @@ pub struct TypedArg {
 impl TaskString {
     // TODO: enable feature for serialize
     // TODO: check if the Minijinja Value can be used.
-    pub fn render(&self, args: Option<&ArgValues>) -> Result<String, anyhow::Error> {
+    pub fn render(&self, args: Option<&ArgValues>) -> Result<String, TaskStringError> {
         // If any of the values are None, we should error
-        if let Some(ArgValues::TypedArgs(args)) = args {
-            let context: indexmap::IndexMap<String, String> = args
-                .iter()
+        let context = if let Some(ArgValues::TypedArgs(args)) = args {
+            args.iter()
                 .map(|arg| (arg.name.clone(), arg.value.clone()))
-                .collect();
-
-            return JINJA_ENV
-                .render_str(&self.0, &context)
-                .map_err(|e| e.into());
-        }
+                .collect()
+        } else {
+            indexmap::IndexMap::<String, String>::new()
+        };
 
-        Ok(self.0.clone())
+        JINJA_ENV
+            .render_str(&self.0, minijinja::Value::from_serialize(context))
+            .map_err(|e| TaskStringError {
+                src: self.0.clone(),
+                err_span: e.range().unwrap_or_default().into(),
+            })
     }
 
     pub fn source(&self) -> &str {
@@ -433,7 +455,7 @@ impl CmdArgs {
     pub fn as_single(
         &self,
         args_values: Option<&ArgValues>,
-    ) -> Result<Option<Cow<str>>, anyhow::Error> {
+    ) -> Result<Option<Cow<str>>, TaskStringError> {
         match self {
             CmdArgs::Single(cmd) => Ok(Some(Cow::Owned(cmd.render(args_values)?))),
             CmdArgs::Multiple(args) => {
@@ -451,7 +473,7 @@ impl CmdArgs {
     pub fn into_single(
         self,
         args_values: Option<&ArgValues>,
-    ) -> Result<Option<String>, anyhow::Error> {
+    ) -> Result<Option<String>, TaskStringError> {
         match self {
             CmdArgs::Single(cmd) => cmd.render(args_values).map(Some),
             CmdArgs::Multiple(args) => {
diff --git a/src/cli/run.rs b/src/cli/run.rs
index c3149a0e5c..ee06f1c4dc 100644
--- a/src/cli/run.rs
+++ b/src/cli/run.rs
@@ -338,6 +338,7 @@ enum TaskExecutionError {
     NonZeroExitCode(i32),
 
     #[error(transparent)]
+    #[diagnostic(transparent)]
     FailedToParseShellScript(#[from] FailedToParseShellScript),
 
     #[error(transparent)]
diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index 78c4aa0d90..c1a1f002d6 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -11,9 +11,9 @@ use deno_task_shell::{
 };
 use fs_err::tokio as tokio_fs;
 use itertools::Itertools;
-use miette::{Context, Diagnostic, SourceSpan};
+use miette::{Context, Diagnostic};
 use pixi_consts::consts;
-use pixi_manifest::{task::ArgValues, Task, TaskName};
+use pixi_manifest::{task::ArgValues, task::TaskStringError, Task, TaskName};
 use pixi_progress::await_in_progress;
 use rattler_lock::LockFile;
 use thiserror::Error;
@@ -29,32 +29,6 @@ use crate::{
     Workspace,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-pub enum ShellParsingError {
-    #[error("failed to parse shell script. Task: '{task}'")]
-    ParseError {
-        #[source]
-        source: anyhow::Error,
-        task: String,
-    },
-
-    #[error("failed to replace argument placeholders")]
-    ArgumentReplacement {
-        #[source_code]
-        src: String,
-        #[label = "this part can't be replaced"]
-        err_span: SourceSpan,
-    },
-}
-
-impl ShellParsingError {
-    pub fn task(&self) -> &str {
-        match self {
-            ShellParsingError::ParseError { task, .. } => task,
-            ShellParsingError::ArgumentReplacement { task, .. } => task,
-        }
-    }
-}
 /// Runs task in project.
 #[derive(Default, Debug)]
 pub struct RunOutput {
@@ -65,10 +39,17 @@ pub struct RunOutput {
 
 #[derive(Debug, Error, Diagnostic)]
 #[error("The task failed to parse")]
-pub struct FailedToParseShellScript {
-    pub script: String,
-    #[source]
-    pub error: ShellParsingError,
+pub enum FailedToParseShellScript {
+    #[error("failed to parse shell script. Task: '{task}'")]
+    ParseError {
+        #[source]
+        source: anyhow::Error,
+        task: String,
+    },
+
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    ArgumentReplacement(#[from] TaskStringError),
 }
 
 #[derive(Debug, Error, Diagnostic)]
@@ -145,14 +126,12 @@ impl<'p> ExecutableTask<'p> {
     }
 
     /// Returns the task as script
-    fn as_script(&self) -> Result<Option<String>, ShellParsingError> {
+    fn as_script(&self) -> Result<Option<String>, FailedToParseShellScript> {
         // Convert the task into an executable string
-        let task = self.task.as_single_command(Some(&self.args)).map_err(|e| {
-            ShellParsingError::ArgumentReplacement {
-                source: e,
-                task: self.task.to_string(),
-            }
-        })?;
+        let task = self
+            .task
+            .as_single_command(Some(&self.args))
+            .map_err(|e| FailedToParseShellScript::ArgumentReplacement(e))?;
         if let Some(task) = task {
             // Get the export specific environment variables
             let export = get_export_specific_task_env(self.task.as_ref());
@@ -186,22 +165,16 @@ impl<'p> ExecutableTask<'p> {
     pub(crate) fn as_deno_script(
         &self,
     ) -> Result<Option<SequentialList>, FailedToParseShellScript> {
-        let full_script = self.as_script().map_err(|e| FailedToParseShellScript {
-            script: e.task().to_string(),
-            error: e,
-        })?;
+        let full_script = self.as_script()?;
 
         if let Some(full_script) = full_script {
             tracing::debug!("Parsing shell script: {}", full_script);
 
             // Parse the shell command
             deno_task_shell::parser::parse(full_script.trim())
-                .map_err(|e| FailedToParseShellScript {
-                    script: full_script.to_string(),
-                    error: ShellParsingError::ParseError {
-                        source: e,
-                        task: full_script.to_string(),
-                    },
+                .map_err(|e| FailedToParseShellScript::ParseError {
+                    source: e,
+                    task: full_script.to_string(),
                 })
                 .map(Some)
         } else {
@@ -387,7 +360,11 @@ impl Display for ExecutableTaskConsoleDisplay<'_, '_> {
                 Ok(())
             }
             Err(err) => {
-                write!(f, "{}", consts::TASK_ERROR_STYLE.apply_to(err).bold())
+                write!(
+                    f,
+                    "{}",
+                    consts::TASK_ERROR_STYLE.apply_to(err.get_source()).bold()
+                )
             }
         }
     }
diff --git a/src/task/task_graph.rs b/src/task/task_graph.rs
index 3f8febbbb8..13608da08c 100644
--- a/src/task/task_graph.rs
+++ b/src/task/task_graph.rs
@@ -96,7 +96,7 @@ impl TaskNode<'_> {
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
     #[cfg(test)]
-    pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
+    pub(crate) fn full_command(&self) -> miette::Result<Option<String>> {
         let mut cmd = self.task.as_single_command(self.args.as_ref())?;
 
         if let Some(ArgValues::FreeFormArgs(additional_args)) = &self.args {

From 20d4424dfab91d39b895f19a3779bf383ef13b06 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Wed, 16 Apr 2025 16:21:31 -0400
Subject: [PATCH 24/39] minor improvement

---
 src/task/executable_task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index c1a1f002d6..2e45cb26b4 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -131,7 +131,7 @@ impl<'p> ExecutableTask<'p> {
         let task = self
             .task
             .as_single_command(Some(&self.args))
-            .map_err(|e| FailedToParseShellScript::ArgumentReplacement(e))?;
+            .map_err(FailedToParseShellScript::ArgumentReplacement)?;
         if let Some(task) = task {
             // Get the export specific environment variables
             let export = get_export_specific_task_env(self.task.as_ref());

From dee22527697b647514e6851b145013fe2163f192 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Wed, 16 Apr 2025 16:43:37 -0400
Subject: [PATCH 25/39] Refactor TaskString rendering logic to use HashMap for
 argument serialization

---
 crates/pixi_manifest/src/task.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 62e8608552..32a4e14971 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -1,5 +1,6 @@
 use std::{
     borrow::Cow,
+    collections::HashMap,
     convert::Infallible,
     fmt::{Display, Formatter},
     path::{Path, PathBuf},
@@ -407,20 +408,19 @@ pub struct TypedArg {
 }
 
 impl TaskString {
-    // TODO: enable feature for serialize
-    // TODO: check if the Minijinja Value can be used.
     pub fn render(&self, args: Option<&ArgValues>) -> Result<String, TaskStringError> {
-        // If any of the values are None, we should error
         let context = if let Some(ArgValues::TypedArgs(args)) = args {
-            args.iter()
-                .map(|arg| (arg.name.clone(), arg.value.clone()))
-                .collect()
+            let args_map: HashMap<&str, &str> = args
+                .iter()
+                .map(|arg| (arg.name.as_str(), arg.value.as_str()))
+                .collect();
+            minijinja::Value::from_serialize(&args_map)
         } else {
-            indexmap::IndexMap::<String, String>::new()
+            minijinja::Value::from_serialize(Vec::<TypedArg>::new())
         };
 
         JINJA_ENV
-            .render_str(&self.0, minijinja::Value::from_serialize(context))
+            .render_str(&self.0, context)
             .map_err(|e| TaskStringError {
                 src: self.0.clone(),
                 err_span: e.range().unwrap_or_default().into(),

From 220c220203a121a64633710a4eb8c89f909bc62b Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Wed, 16 Apr 2025 23:45:35 -0400
Subject: [PATCH 26/39] Update error message in CLI test for undefined
 arguments

---
 tests/integration_python/test_run_cli.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index f0ebf61317..2d0a623847 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -849,7 +849,7 @@ def test_undefined_arguments_in_command(pixi: Path, tmp_pixi_workspace: Path) ->
     verify_cli_command(
         [pixi, "run", "--manifest-path", manifest_path, "mixed_args", "test.py"],
         ExitCode.FAILURE,
-        stderr_contains="Failed to replace argument placeholders",
+        stderr_contains="this part can't be replaced",
     )
 
 

From c3f6d569c03d9484d1570da67b47e5255c10bc01 Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Wed, 16 Apr 2025 23:50:32 -0400
Subject: [PATCH 27/39] add a test using minijinja filters

---
 tests/integration_python/test_run_cli.py | 28 ++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index 2d0a623847..96da393b19 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -1120,3 +1120,31 @@ def test_short_circuit_composition(pixi: Path, tmp_pixi_workspace: Path) -> None
 
     assert output1.stdout == output2.stdout
     assert output1.stderr == output2.stderr
+
+
+def test_task_minijinja_title_filter(pixi: Path, tmp_pixi_workspace: Path) -> None:
+    """Test that minijinja title filter works as expected in task strings."""
+    manifest_path = tmp_pixi_workspace.joinpath("pixi.toml")
+
+    manifest_content = tomli.loads(EMPTY_BOILERPLATE_PROJECT)
+
+    manifest_content["tasks"] = {
+        "title-filter": {"cmd": "echo {{ name|title }}", "args": [{"arg": "name"}]},
+    }
+
+    manifest_path.write_text(tomli_w.dumps(manifest_content))
+
+    verify_cli_command(
+        [pixi, "run", "--manifest-path", manifest_path, "title-filter", '"hello world"'],
+        stdout_contains="Hello World",
+    )
+
+    verify_cli_command(
+        [pixi, "run", "--manifest-path", manifest_path, "title-filter", '"hElLo wOrLd"'],
+        stdout_contains="Hello World",
+    )
+
+    verify_cli_command(
+        [pixi, "run", "--manifest-path", manifest_path, "title-filter", '"HELLO WORLD"'],
+        stdout_contains="Hello World",
+    )

From 6292d748ec78e4e345922d71aa5e49a3eeb6453f Mon Sep 17 00:00:00 2001
From: prsabahrami <p.bahraminejad@gmail.com>
Date: Thu, 17 Apr 2025 00:03:47 -0400
Subject: [PATCH 28/39] update docs

---
 docs/workspace/advanced_tasks.md | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/docs/workspace/advanced_tasks.md b/docs/workspace/advanced_tasks.md
index 65eff124e4..bac9f46bd3 100644
--- a/docs/workspace/advanced_tasks.md
+++ b/docs/workspace/advanced_tasks.md
@@ -181,6 +181,9 @@ Define arguments in your task using the `args` field:
 --8<-- "docs/source_files/pixi_tomls/task_arguments.toml:project_tasks"
 ```
 
+!!! note "Argument naming restrictions"
+    Argument names cannot contain dashes (`-`). Use underscores (`_`) or camelCase instead.
+
 ### Using Task Arguments
 
 When running a task, provide arguments in the order they are defined:
@@ -234,6 +237,30 @@ pixi run partial-override
 ✨ Pixi task (base-task in default): echo Base task with override1 and default2
 ```
 
+### MiniJinja Templating for Task Arguments
+
+Task commands support MiniJinja templating syntax for accessing and formatting argument values. This provides powerful flexibility when constructing commands.
+
+Basic syntax for using an argument in your command:
+
+```toml
+[tasks]
+greet = { cmd = "echo Hello, {{ name }}!", args = ["name"] }
+```
+
+You can also use filters to transform argument values:
+
+```toml
+[tasks]
+# Convert argument to uppercase
+upper = { cmd = "echo {{ text | upper }}", args = ["text"] }
+
+# Join a list with commas
+files = { cmd = "tar -czf archive.tar.gz {{ files | join(',') }}", args = ["files"] }
+```
+
+For more information about available filters and template syntax, see the [MiniJinja documentation](https://docs.rs/minijinja/latest/minijinja/filters/index.html).
+
 ## Caching
 
 When you specify `inputs` and/or `outputs` to a task, Pixi will reuse the result of the task.

From 6a5d4e9256c9cef0122eab9dc9f2624a8551ab3d Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 09:16:43 +0200
Subject: [PATCH 29/39] Small cleanup

---
 Cargo.lock                       |  1 -
 crates/pixi_manifest/Cargo.toml  |  3 +--
 crates/pixi_manifest/src/task.rs | 23 ++---------------------
 3 files changed, 3 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 168f8a7984..3950c38bef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4665,7 +4665,6 @@ dependencies = [
 name = "pixi_manifest"
 version = "0.1.0"
 dependencies = [
- "anyhow",
  "assert_matches",
  "console",
  "dunce",
diff --git a/crates/pixi_manifest/Cargo.toml b/crates/pixi_manifest/Cargo.toml
index cc0227b262..433547cd8c 100644
--- a/crates/pixi_manifest/Cargo.toml
+++ b/crates/pixi_manifest/Cargo.toml
@@ -44,8 +44,7 @@ rattler_virtual_packages = { workspace = true }
 rattler_lock = { workspace = true, optional = true }
 rattler_solve = { workspace = true, optional = true }
 
-# TODO: Remove these dependencies
-anyhow = "1.0.97"
+
 console = { workspace = true }
 miette = { workspace = true, features = ["fancy-no-backtrace"] }
 minijinja = { workspace = true, features = ["builtins"] }
diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 32a4e14971..5ef4db3560 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -112,30 +112,11 @@ impl Task {
         }
     }
 
-    /// If this task is a plain task, returns the task string
-    pub fn as_plain(&self) -> Result<String, TaskStringError> {
-        match self {
-            Task::Plain(str) => str.render(None),
-            _ => Err(TaskStringError {
-                src: "".to_string(),
-                err_span: SourceSpan::new(0.into(), 0),
-            }),
-        }
-    }
-
     /// If this command is an execute command, returns the `Execute` task.
-    pub fn as_execute(&self) -> Result<&Execute, anyhow::Error> {
+    pub fn as_execute(&self) -> Result<&Execute, miette::Report> {
         match self {
             Task::Execute(execute) => Ok(execute),
-            _ => Err(anyhow::anyhow!("Task is not an execute task")),
-        }
-    }
-
-    /// If this command is an alias, returns the `Alias` task.
-    pub fn as_alias(&self) -> Result<&Alias, anyhow::Error> {
-        match self {
-            Task::Alias(alias) => Ok(alias),
-            _ => Err(anyhow::anyhow!("Task is not an alias task")),
+            _ => Err(miette::miette!("Task is not an execute task")),
         }
     }
 

From 62002e9300411bf4bbe834819169c4d620c97448 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 09:22:04 +0200
Subject: [PATCH 30/39] Small simplification

---
 crates/pixi_manifest/src/task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/pixi_manifest/src/task.rs b/crates/pixi_manifest/src/task.rs
index 5ef4db3560..9275b8436e 100644
--- a/crates/pixi_manifest/src/task.rs
+++ b/crates/pixi_manifest/src/task.rs
@@ -397,7 +397,7 @@ impl TaskString {
                 .collect();
             minijinja::Value::from_serialize(&args_map)
         } else {
-            minijinja::Value::from_serialize(Vec::<TypedArg>::new())
+            minijinja::Value::default()
         };
 
         JINJA_ENV

From 7e184899f9cdd4f223a786389d92a98a82440ddc Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 09:41:30 +0200
Subject: [PATCH 31/39] Adapt docs

---
 .../pixi_tomls/task_minijinja_filter.toml          | 10 ++++++++++
 .../pixi_tomls/task_minijinja_simple.toml          |  9 +++++++++
 docs/workspace/advanced_tasks.md                   | 14 ++++----------
 3 files changed, 23 insertions(+), 10 deletions(-)
 create mode 100644 docs/source_files/pixi_tomls/task_minijinja_filter.toml
 create mode 100644 docs/source_files/pixi_tomls/task_minijinja_simple.toml

diff --git a/docs/source_files/pixi_tomls/task_minijinja_filter.toml b/docs/source_files/pixi_tomls/task_minijinja_filter.toml
new file mode 100644
index 0000000000..946c81e801
--- /dev/null
+++ b/docs/source_files/pixi_tomls/task_minijinja_filter.toml
@@ -0,0 +1,10 @@
+
+[workspace]
+channels = ["conda-forge"]
+name = "workspace-name"
+platforms = ["linux-64"]
+# --8<-- [start:tasks]
+[tasks]
+# Convert argument to uppercase
+upper = { cmd = "echo {{ text | upper }}", args = ["text"] }
+# --8<-- [end:tasks]
diff --git a/docs/source_files/pixi_tomls/task_minijinja_simple.toml b/docs/source_files/pixi_tomls/task_minijinja_simple.toml
new file mode 100644
index 0000000000..178758018d
--- /dev/null
+++ b/docs/source_files/pixi_tomls/task_minijinja_simple.toml
@@ -0,0 +1,9 @@
+
+[workspace]
+channels = ["conda-forge"]
+name = "workspace-name"
+platforms = ["linux-64"]
+# --8<-- [start:tasks]
+[tasks]
+greet = { cmd = "echo Hello, {{ name }}!", args = ["name"] }
+# --8<-- [end:tasks]
diff --git a/docs/workspace/advanced_tasks.md b/docs/workspace/advanced_tasks.md
index bac9f46bd3..b31a550abf 100644
--- a/docs/workspace/advanced_tasks.md
+++ b/docs/workspace/advanced_tasks.md
@@ -243,20 +243,14 @@ Task commands support MiniJinja templating syntax for accessing and formatting a
 
 Basic syntax for using an argument in your command:
 
-```toml
-[tasks]
-greet = { cmd = "echo Hello, {{ name }}!", args = ["name"] }
+```toml title="pixi.toml"
+--8<-- "docs/source_files/pixi_tomls/task_minijinja_simple.toml:tasks"
 ```
 
 You can also use filters to transform argument values:
 
-```toml
-[tasks]
-# Convert argument to uppercase
-upper = { cmd = "echo {{ text | upper }}", args = ["text"] }
-
-# Join a list with commas
-files = { cmd = "tar -czf archive.tar.gz {{ files | join(',') }}", args = ["files"] }
+```toml title="pixi.toml"
+--8<-- "docs/source_files/pixi_tomls/task_minijinja_filter.toml:tasks"
 ```
 
 For more information about available filters and template syntax, see the [MiniJinja documentation](https://docs.rs/minijinja/latest/minijinja/filters/index.html).

From ba6c715bb6f00e71f013d6eda446a898bd7fa7b9 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 09:58:59 +0200
Subject: [PATCH 32/39] Update lock file

---
 pixi_docs/Cargo.lock | 350 +++++++++++++++++++------------------------
 1 file changed, 157 insertions(+), 193 deletions(-)

diff --git a/pixi_docs/Cargo.lock b/pixi_docs/Cargo.lock
index 0ef3e50ae5..8baeaf55d7 100644
--- a/pixi_docs/Cargo.lock
+++ b/pixi_docs/Cargo.lock
@@ -123,9 +123,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "arbitrary"
@@ -511,9 +511,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-sso"
-version = "1.62.0"
+version = "1.64.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d5330ad4e8a1ff49e9f26b738611caa72b105c41d41733801d1a36e8f9de936"
+checksum = "02d4bdb0e5f80f0689e61c77ab678b2b9304af329616af38aef5b6b967b8e736"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -525,6 +525,7 @@ dependencies = [
  "aws-smithy-types",
  "aws-types",
  "bytes",
+ "fastrand",
  "http 0.2.12",
  "once_cell",
  "regex-lite",
@@ -533,9 +534,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-ssooidc"
-version = "1.63.0"
+version = "1.65.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7956b1a85d49082347a7d17daa2e32df191f3e23c03d47294b99f95413026a78"
+checksum = "acbbb3ce8da257aedbccdcb1aadafbbb6a5fe9adf445db0e1ea897bdc7e22d08"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -547,6 +548,7 @@ dependencies = [
  "aws-smithy-types",
  "aws-types",
  "bytes",
+ "fastrand",
  "http 0.2.12",
  "once_cell",
  "regex-lite",
@@ -555,9 +557,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-sts"
-version = "1.63.0"
+version = "1.65.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "065c533fbe6f84962af33fcf02b0350b7c1f79285baab5924615d2be3b232855"
+checksum = "96a78a8f50a1630db757b60f679c8226a8a70ee2ab5f5e6e51dc67f6c61c7cfd"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -570,6 +572,7 @@ dependencies = [
  "aws-smithy-types",
  "aws-smithy-xml",
  "aws-types",
+ "fastrand",
  "http 0.2.12",
  "once_cell",
  "regex-lite",
@@ -693,14 +696,14 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-http-client"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0497ef5d53065b7cd6a35e9c1654bd1fefeae5c52900d91d1b188b0af0f29324"
+checksum = "8aff1159006441d02e57204bf57a1b890ba68bedb6904ffd2873c1c4c11c546b"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
- "h2 0.4.8",
+ "h2 0.4.9",
  "http 0.2.12",
  "http-body 0.4.6",
  "hyper 0.14.32",
@@ -833,9 +836,9 @@ dependencies = [
 
 [[package]]
 name = "backon"
-version = "1.4.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "970d91570c01a8a5959b36ad7dd1c30642df24b6b3068710066f6809f7033bb7"
+checksum = "fd0b50b1b78dbadd44ab18b3c794e496f3a139abb9fbc27d9c94c4eebbb96496"
 dependencies = [
  "fastrand",
  "gloo-timers 0.3.0",
@@ -990,9 +993,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.11.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
  "regex-automata 0.4.9",
@@ -1104,9 +1107,9 @@ checksum = "1bf2a5fb3207c12b5d208ebc145f967fea5cac41a021c37417ccc31ba40f39ee"
 
 [[package]]
 name = "cargo-util"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "932c5376dc904ef005f0d229a5edc1116f40a78a18d30cdc992ec5acbeffd4d9"
+checksum = "527f6e2a4e80492e90628052be879a5996c2453ad5ec745bfa310a80b7eca20a"
 dependencies = [
  "anyhow",
  "core-foundation 0.10.0",
@@ -1136,9 +1139,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.16"
+version = "1.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362"
 dependencies = [
  "jobserver",
  "libc",
@@ -1200,9 +1203,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -1210,9 +1213,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1407,9 +1410,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.14"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -1494,9 +1497,9 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.4.5"
+version = "3.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
+checksum = "697b5419f348fd5ae2478e8018cb016c00a5881c7f46c717de98ffd135a5651c"
 dependencies = [
  "nix",
  "windows-sys 0.59.0",
@@ -1504,9 +1507,9 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.20.10"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -1514,9 +1517,9 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.10"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
 dependencies = [
  "fnv",
  "ident_case",
@@ -1528,9 +1531,9 @@ dependencies = [
 
 [[package]]
 name = "darling_macro"
-version = "0.20.10"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core",
  "quote",
@@ -1553,9 +1556,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
 name = "dbus"
@@ -1696,34 +1699,13 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "dirs"
-version = "5.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
-dependencies = [
- "dirs-sys 0.4.1",
-]
-
 [[package]]
 name = "dirs"
 version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
 dependencies = [
- "dirs-sys 0.5.0",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
-dependencies = [
- "libc",
- "option-ext",
- "redox_users 0.4.6",
- "windows-sys 0.48.0",
+ "dirs-sys",
 ]
 
 [[package]]
@@ -1734,7 +1716,7 @@ checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
 dependencies = [
  "libc",
  "option-ext",
- "redox_users 0.5.0",
+ "redox_users",
  "windows-sys 0.59.0",
 ]
 
@@ -1907,9 +1889,9 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.10"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
+checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
 dependencies = [
  "libc",
  "windows-sys 0.59.0",
@@ -1939,9 +1921,9 @@ dependencies = [
 
 [[package]]
 name = "event-listener-strategy"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c3e4e0dd3673c1139bf041f3008816d9cf2946bbfac2945c09e523b8d7b05b2"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
 dependencies = [
  "event-listener",
  "pin-project-lite",
@@ -2003,9 +1985,9 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "flate2"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11faaf5a5236997af9848be0bef4db95824b1d534ebc64d0f0c6cf3e67bd38dc"
+checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece"
 dependencies = [
  "crc32fast",
  "libz-rs-sys",
@@ -2069,7 +2051,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"
 dependencies = [
  "fs-err",
- "rustix 1.0.3",
+ "rustix 1.0.5",
  "tokio",
  "windows-sys 0.59.0",
 ]
@@ -2437,9 +2419,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5017294ff4bb30944501348f6f8e42e6ad28f42c8bbef7a74029aff064a4e3c2"
+checksum = "75249d144030531f8dee69fe9cea04d3edf809a017ae445e2abdff6629e86633"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -2738,7 +2720,7 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2 0.4.8",
+ "h2 0.4.9",
  "http 1.3.1",
  "http-body 1.0.1",
  "httparse",
@@ -2776,7 +2758,7 @@ dependencies = [
  "hyper 1.6.0",
  "hyper-util",
  "log",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-native-certs 0.8.1",
  "rustls-pki-types",
  "tokio",
@@ -2787,9 +2769,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4"
+checksum = "497bbc33a26fdd4af9ed9c70d63f61cf56a938375fbb32df34db9b1cd6d643f2"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -2797,6 +2779,7 @@ dependencies = [
  "http 1.3.1",
  "http-body 1.0.1",
  "hyper 1.6.0",
+ "libc",
  "pin-project-lite",
  "socket2",
  "tokio",
@@ -2806,16 +2789,17 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.61"
+version = "0.1.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
- "windows-core 0.52.0",
+ "windows-core 0.61.0",
 ]
 
 [[package]]
@@ -2868,9 +2852,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locid_transform_data"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+checksum = "7515e6d781098bf9f7205ab3fc7e9709d34554ae0b21ddbcb5febfa4bc7df11d"
 
 [[package]]
 name = "icu_normalizer"
@@ -2892,9 +2876,9 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+checksum = "c5e8338228bdc8ab83303f16b797e177953730f601a96c25d10cb3ab0daa0cb7"
 
 [[package]]
 name = "icu_properties"
@@ -2913,9 +2897,9 @@ dependencies = [
 
 [[package]]
 name = "icu_properties_data"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+checksum = "85fb8799753b75aee8d2a21d7c14d9f38921b54b3dbda10f5a3c7a7b82dba5e2"
 
 [[package]]
 name = "icu_provider"
@@ -3122,9 +3106,9 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jiff"
-version = "0.2.4"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d699bc6dfc879fb1bf9bdff0d4c56f0884fc6f0d0eb0fba397a6d00cd9a6b85e"
+checksum = "e5ad87c89110f55e4cd4dc2893a9790820206729eaf221555f742d540b0724a0"
 dependencies = [
  "jiff-static",
  "jiff-tzdb-platform",
@@ -3137,9 +3121,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.4"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d16e75759ee0aa64c57a56acbf43916987b20c77373cb7e808979e02b93c9f9"
+checksum = "d076d5b64a7e2fe6f0743f02c43ca4a6725c0f904203bfe276a5b3e793103605"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3148,15 +3132,15 @@ dependencies = [
 
 [[package]]
 name = "jiff-tzdb"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "962e1dfe9b2d75a84536cf5bf5eaaa4319aa7906c7160134a22883ac316d5f31"
+checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
 
 [[package]]
 name = "jiff-tzdb-platform"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a63c62e404e7b92979d2792352d885a7f8f83fd1d0d31eea582d77b2ceca697e"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
 dependencies = [
  "jiff-tzdb",
 ]
@@ -3185,10 +3169,11 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "jobserver"
-version = "0.1.32"
+version = "0.1.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
+checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
 dependencies = [
+ "getrandom 0.3.2",
  "libc",
 ]
 
@@ -3251,7 +3236,7 @@ dependencies = [
  "http 1.3.1",
  "jsonrpsee-core",
  "pin-project",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-pki-types",
  "rustls-platform-verifier",
  "soketto",
@@ -3302,7 +3287,7 @@ dependencies = [
  "hyper-util",
  "jsonrpsee-core",
  "jsonrpsee-types",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-platform-verifier",
  "serde",
  "serde_json",
@@ -3430,9 +3415,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libdbus-sys"
@@ -3467,14 +3452,14 @@ checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
  "bitflags 2.9.0",
  "libc",
- "redox_syscall 0.5.10",
+ "redox_syscall 0.5.11",
 ]
 
 [[package]]
 name = "libz-rs-sys"
-version = "0.4.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "902bc563b5d65ad9bba616b490842ef0651066a1a1dc3ce1087113ffcb873c8d"
+checksum = "6489ca9bd760fe9642d7644e827b0c9add07df89857b0416ee15c1cc1a3b8c5a"
 dependencies = [
  "zlib-rs",
 ]
@@ -3487,9 +3472,9 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "litemap"
@@ -3515,9 +3500,9 @@ checksum = "9374ef4228402d4b7e403e5838cb880d9ee663314b0a900d5a6aabf0c213552e"
 
 [[package]]
 name = "log"
-version = "0.4.26"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "loom"
@@ -3686,9 +3671,9 @@ dependencies = [
 
 [[package]]
 name = "minijinja"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e36f1329330bb1614c94b78632b9ce45dd7d761f3304a1bed07b2990a7c5097"
+checksum = "98642a6dfca91122779a307b77cd07a4aa951fbe32232aaf5bad9febc66be754"
 dependencies = [
  "serde",
 ]
@@ -3701,9 +3686,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e3e04debbb59698c15bacbb6d93584a8c0ca9cc3213cb423d31f760d8843ce5"
+checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
 dependencies = [
  "adler2",
 ]
@@ -4049,7 +4034,7 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.5.10",
+ "redox_syscall 0.5.11",
  "smallvec",
  "windows-targets 0.52.6",
 ]
@@ -4250,7 +4235,7 @@ dependencies = [
  "ctrlc",
  "deno_task_shell",
  "dialoguer",
- "dirs 6.0.0",
+ "dirs",
  "dunce",
  "fancy_display",
  "flate2",
@@ -4422,7 +4407,7 @@ version = "0.1.0"
 dependencies = [
  "clap",
  "console",
- "dirs 6.0.0",
+ "dirs",
  "fs-err",
  "itertools 0.14.0",
  "miette 7.5.0",
@@ -4506,7 +4491,6 @@ dependencies = [
 name = "pixi_manifest"
 version = "0.1.0"
 dependencies = [
- "anyhow",
  "console",
  "dunce",
  "fancy_display",
@@ -4579,7 +4563,7 @@ dependencies = [
 name = "pixi_spec"
 version = "0.1.0"
 dependencies = [
- "dirs 6.0.0",
+ "dirs",
  "file_url",
  "itertools 0.14.0",
  "pixi_git",
@@ -4690,9 +4674,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
 [[package]]
 name = "plist"
-version = "1.7.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42cf17e9a1800f5f396bc67d193dc9411b59012a5876445ef450d449881e1016"
+checksum = "eac26e981c03a6e53e0aee43c113e3202f5581d5360dae7bd2c70e800dd0451d"
 dependencies = [
  "base64 0.22.1",
  "indexmap 2.9.0",
@@ -4752,7 +4736,7 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
 dependencies = [
- "zerocopy 0.8.23",
+ "zerocopy 0.8.24",
 ]
 
 [[package]]
@@ -4777,9 +4761,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -4924,9 +4908,9 @@ dependencies = [
 
 [[package]]
 name = "quick-xml"
-version = "0.37.2"
+version = "0.37.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "165859e9e55f79d67b96c5d96f4e88b6f2695a1972849c15a6a3f5c59fc2c003"
+checksum = "a4ce8c88de324ff838700f36fb6ab86c96df0e3c4ab6ef3a9b2044465cce1369"
 dependencies = [
  "memchr",
 ]
@@ -4943,7 +4927,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "socket2",
  "thiserror 2.0.12",
  "tokio",
@@ -4962,7 +4946,7 @@ dependencies = [
  "rand 0.9.0",
  "ring",
  "rustc-hash",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-pki-types",
  "slab",
  "thiserror 2.0.12",
@@ -4973,9 +4957,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.10"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e46f3055866785f6b92bc6164b76be02ca8f2eb4b002c0354b28cf4c119e5944"
+checksum = "541d0f57c6ec747a90738a52741d3221f7960e8ac2f0ff4b1a63680e033b4ab5"
 dependencies = [
  "cfg_aliases",
  "libc",
@@ -5040,7 +5024,7 @@ checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
- "zerocopy 0.8.23",
+ "zerocopy 0.8.24",
 ]
 
 [[package]]
@@ -5091,7 +5075,7 @@ dependencies = [
  "clap",
  "console",
  "digest",
- "dirs 6.0.0",
+ "dirs",
  "fs-err",
  "futures",
  "humantime",
@@ -5134,7 +5118,7 @@ dependencies = [
  "anyhow",
  "dashmap",
  "digest",
- "dirs 6.0.0",
+ "dirs",
  "fs-err",
  "fs4",
  "futures",
@@ -5165,7 +5149,7 @@ checksum = "21c2ed99f2fc8044499c63c65db265f6ec3e0333cdf15bb442d5063187449d51"
 dependencies = [
  "chrono",
  "core-foundation 0.10.0",
- "dirs 6.0.0",
+ "dirs",
  "file_url",
  "fs-err",
  "fxhash",
@@ -5258,12 +5242,12 @@ checksum = "eb3eedb82b5366136093acb1bafc4839f3f122c64889a358cbe6e50fc8c573b0"
 dependencies = [
  "chrono",
  "configparser",
- "dirs 6.0.0",
+ "dirs",
  "fs-err",
  "known-folders",
  "once_cell",
  "plist",
- "quick-xml 0.37.2",
+ "quick-xml 0.37.4",
  "rattler_conda_types",
  "rattler_shell",
  "regex",
@@ -5291,7 +5275,7 @@ dependencies = [
  "aws-config",
  "aws-sdk-s3",
  "base64 0.22.1",
- "dirs 6.0.0",
+ "dirs",
  "fs-err",
  "getrandom 0.2.15",
  "google-cloud-auth",
@@ -5379,7 +5363,7 @@ dependencies = [
  "cfg-if",
  "chrono",
  "dashmap",
- "dirs 6.0.0",
+ "dirs",
  "file_url",
  "fs-err",
  "futures",
@@ -5511,24 +5495,13 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.10"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3"
 dependencies = [
  "bitflags 2.9.0",
 ]
 
-[[package]]
-name = "redox_users"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
-dependencies = [
- "getrandom 0.2.15",
- "libredox",
- "thiserror 1.0.69",
-]
-
 [[package]]
 name = "redox_users"
 version = "0.5.0"
@@ -5568,7 +5541,7 @@ checksum = "78c81d000a2c524133cc00d2f92f019d399e57906c3b7119271a2495354fe895"
 dependencies = [
  "cfg-if",
  "libc",
- "rustix 1.0.3",
+ "rustix 1.0.5",
  "windows 0.61.1",
 ]
 
@@ -5650,7 +5623,7 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2 0.4.8",
+ "h2 0.4.9",
  "http 1.3.1",
  "http-body 1.0.1",
  "http-body-util",
@@ -5666,7 +5639,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-native-certs 0.8.1",
  "rustls-pemfile 2.2.0",
  "rustls-pki-types",
@@ -5916,14 +5889,14 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.3"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e56a18552996ac8d29ecc3b190b4fdbb2d91ca4ec396de7bbffaf43f3d637e96"
+checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
 dependencies = [
  "bitflags 2.9.0",
  "errno",
  "libc",
- "linux-raw-sys 0.9.3",
+ "linux-raw-sys 0.9.4",
  "windows-sys 0.59.0",
 ]
 
@@ -5941,15 +5914,15 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.25"
+version = "0.23.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "822ee9188ac4ec04a2f0531e55d035fb2de73f18b41a63c70c2712503b6fb13c"
+checksum = "df51b5869f3a441595eac5e8ff14d486ff285f7b8c0df8770e49c3b56351f0f0"
 dependencies = [
  "log",
  "once_cell",
  "ring",
  "rustls-pki-types",
- "rustls-webpki 0.103.0",
+ "rustls-webpki 0.103.1",
  "subtle",
  "zeroize",
 ]
@@ -6016,10 +5989,10 @@ dependencies = [
  "jni",
  "log",
  "once_cell",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-native-certs 0.8.1",
  "rustls-platform-verifier-android",
- "rustls-webpki 0.103.0",
+ "rustls-webpki 0.103.1",
  "security-framework 3.2.0",
  "security-framework-sys",
  "webpki-root-certs",
@@ -6044,9 +6017,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.0"
+version = "0.103.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0aa4eeac2588ffff23e9d7a7e9b3f971c5fb5b7ebc9452745e0c232c64f83b2f"
+checksum = "fef8b8769aaccf73098557a87cd1816b4f9c7c16811c9c77142aa695c16f2c03"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -6131,9 +6104,9 @@ dependencies = [
 
 [[package]]
 name = "scroll_derive"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f81c2fde025af7e69b1d1420531c8a8811ca898919db177141a85313b1cb932"
+checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -6238,9 +6211,9 @@ dependencies = [
 
 [[package]]
 name = "self_cell"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2fdfc24bc566f839a2da4c4295b82db7d25a24253867d5c64355abb5799bdbe"
+checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
 
 [[package]]
 name = "semver"
@@ -6469,12 +6442,12 @@ checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
 [[package]]
 name = "shellexpand"
-version = "3.1.0"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
+checksum = "8b1fdf65dd6331831494dd616b30351c38e96e45921a27745cf98490458b90bb"
 dependencies = [
  "bstr",
- "dirs 5.0.1",
+ "dirs",
  "os_str_bytes",
 ]
 
@@ -6604,9 +6577,9 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 
 [[package]]
 name = "socket2"
-version = "0.5.8"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
+checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
@@ -6883,7 +6856,7 @@ dependencies = [
  "fastrand",
  "getrandom 0.3.2",
  "once_cell",
- "rustix 1.0.3",
+ "rustix 1.0.5",
  "windows-sys 0.59.0",
 ]
 
@@ -6893,7 +6866,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "45c6481c4829e4cc63825e62c49186a34538b7b2750b73b266581ffb612fb5ed"
 dependencies = [
- "rustix 1.0.3",
+ "rustix 1.0.5",
  "windows-sys 0.59.0",
 ]
 
@@ -6960,9 +6933,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.40"
+version = "0.3.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d9c75b47bdff86fa3334a3db91356b8d7d86a9b839dab7d0bdc5c3d3a077618"
+checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
 dependencies = [
  "deranged",
  "itoa",
@@ -6981,9 +6954,9 @@ checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
 
 [[package]]
 name = "time-macros"
-version = "0.2.21"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29aa485584182073ed57fd5004aa09c371f021325014694e432313345865fd04"
+checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49"
 dependencies = [
  "num-conv",
  "time-core",
@@ -7064,7 +7037,7 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b"
 dependencies = [
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "tokio",
 ]
 
@@ -8656,14 +8629,14 @@ dependencies = [
 
 [[package]]
 name = "which"
-version = "7.0.2"
+version = "7.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2774c861e1f072b3aadc02f8ba886c26ad6321567ecc294c935434cad06f1283"
+checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
 dependencies = [
  "either",
  "env_home",
  "regex",
- "rustix 0.38.44",
+ "rustix 1.0.5",
  "winsafe 0.0.19",
 ]
 
@@ -8771,15 +8744,6 @@ dependencies = [
  "windows-core 0.61.0",
 ]
 
-[[package]]
-name = "windows-core"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.57.0"
@@ -9311,9 +9275,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
 name = "winnow"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e97b544156e9bebe1a0ffbc03484fc1ffe3100cbce3ffb17eac35f7cdd7ab36"
+checksum = "63d3fcd9bba44b03821e7d699eeee959f3126dcc4aa8e4ae18ec617c2a5cea10"
 dependencies = [
  "memchr",
 ]
@@ -9376,7 +9340,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e"
 dependencies = [
  "libc",
- "rustix 1.0.3",
+ "rustix 1.0.5",
 ]
 
 [[package]]
@@ -9507,11 +9471,11 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.23"
+version = "0.8.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd97444d05a4328b90e75e503a34bad781f14e28a823ad3557f0750df1ebcbc6"
+checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
 dependencies = [
- "zerocopy-derive 0.8.23",
+ "zerocopy-derive 0.8.24",
 ]
 
 [[package]]
@@ -9527,9 +9491,9 @@ dependencies = [
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.23"
+version = "0.8.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6352c01d0edd5db859a63e2605f4ea3183ddbd15e2c4a9e7d32184df75e4f154"
+checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -9603,9 +9567,9 @@ dependencies = [
 
 [[package]]
 name = "zlib-rs"
-version = "0.4.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b20717f0917c908dc63de2e44e97f1e6b126ca58d0e391cee86d504eb8fbd05"
+checksum = "868b928d7949e09af2f6086dfc1e01936064cc7a819253bce650d4e2a2d63ba8"
 
 [[package]]
 name = "zopfli"

From 4e073205c8abf2025fbeadbfda496f5d57b9c8f3 Mon Sep 17 00:00:00 2001
From: Hofer-Julian <30049909+Hofer-Julian@users.noreply.github.com>
Date: Thu, 17 Apr 2025 10:53:36 +0200
Subject: [PATCH 33/39] Update docs/workspace/advanced_tasks.md

Co-authored-by: Ruben Arts <ruben@prefix.dev>
---
 docs/workspace/advanced_tasks.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/workspace/advanced_tasks.md b/docs/workspace/advanced_tasks.md
index b31a550abf..b338547f0c 100644
--- a/docs/workspace/advanced_tasks.md
+++ b/docs/workspace/advanced_tasks.md
@@ -182,7 +182,7 @@ Define arguments in your task using the `args` field:
 ```
 
 !!! note "Argument naming restrictions"
-    Argument names cannot contain dashes (`-`). Use underscores (`_`) or camelCase instead.
+    Argument names cannot contain dashes (`-`) due to them being seen as a minus sign in MiniJinja. Use underscores (`_`) or camelCase instead.
 
 ### Using Task Arguments
 

From a2ccb99cd861ad5612bfab148e98615a5ec71728 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 11:14:40 +0200
Subject: [PATCH 34/39] Extend test

---
 tests/integration_python/test_run_cli.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/tests/integration_python/test_run_cli.py b/tests/integration_python/test_run_cli.py
index 96da393b19..aacaf3379e 100644
--- a/tests/integration_python/test_run_cli.py
+++ b/tests/integration_python/test_run_cli.py
@@ -846,12 +846,28 @@ def test_undefined_arguments_in_command(pixi: Path, tmp_pixi_workspace: Path) ->
     }
     manifest_path.write_text(tomli_w.dumps(manifest_content))
 
+    # Non existing arguments should fail
     verify_cli_command(
         [pixi, "run", "--manifest-path", manifest_path, "mixed_args", "test.py"],
         ExitCode.FAILURE,
         stderr_contains="this part can't be replaced",
     )
 
+    manifest_content["tasks"] = {
+        "mixed_args": {
+            "cmd": "echo Python file: {{ python_file }} with {{ non_existing_argument | upper }}",
+            "args": ["python_file"],
+        }
+    }
+    manifest_path.write_text(tomli_w.dumps(manifest_content))
+
+    # If the non existing argument is passed to a filter, minijinja doesn't error
+    # Even though we don't like this behaviour we want to make sure that it stays that way
+    verify_cli_command(
+        [pixi, "run", "--manifest-path", manifest_path, "mixed_args", "test.py"],
+        ExitCode.SUCCESS,
+    )
+
 
 def test_task_args_multiple_inputs(pixi: Path, tmp_pixi_workspace: Path) -> None:
     """Test task arguments with multiple inputs."""

From 7f15b9ef1c8b9152c0c2d62f97ea87571e5c2782 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 14:13:59 +0200
Subject: [PATCH 35/39] Update schema and test functions

---
 schema/model.py         |  9 +++++----
 schema/schema.json      | 14 +++++++++++++-
 schema/test_manifest.py | 16 ++++++----------
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/schema/model.py b/schema/model.py
index bc13e31449..19fe3aba95 100644
--- a/schema/model.py
+++ b/schema/model.py
@@ -120,7 +120,6 @@ class Workspace(StrictBaseModel):
         None, description="The authors of the project", examples=["John Doe <j.doe@prefix.dev>"]
     )
     channels: list[Channel] = Field(
-        None,
         description="The `conda` channels that can be used in the project. Unless overridden by `priority`, the first channel listed will be preferred.",
     )
     channel_priority: ChannelPriority | None = Field(
@@ -130,7 +129,9 @@ class Workspace(StrictBaseModel):
         "- 'strict': only take the package from the channel it exist in first."
         "- 'disabled': group all dependencies together as if there is no channel difference.",
     )
-    platforms: list[Platform] = Field(description="The platforms that the project supports")
+    platforms: list[Platform] | None = Field(
+        None, description="The platforms that the project supports"
+    )
     license: NonEmptyStr | None = Field(
         None,
         description="The license of the project; we advise using an [SPDX](https://spdx.org/licenses/) identifier.",
@@ -496,7 +497,7 @@ class Feature(StrictBaseModel):
     pypi_dependencies: dict[PyPIPackageName, PyPIRequirement] | None = Field(
         None, description="The PyPI dependencies of this feature"
     )
-    tasks: dict[TaskName, TaskInlineTable | NonEmptyStr] | None = Field(
+    tasks: dict[TaskName, TaskInlineTable | list[DependsOn] | NonEmptyStr] | None = Field(
         None, description="The tasks provided by this feature"
     )
     activation: Activation | None = Field(
@@ -701,7 +702,7 @@ class Config:
         None, description="The PyPI dependencies"
     )
     pypi_options: PyPIOptions | None = Field(None, description="Options related to PyPI indexes")
-    tasks: dict[TaskName, TaskInlineTable | NonEmptyStr] | None = Field(
+    tasks: dict[TaskName, TaskInlineTable | list[DependsOn] | NonEmptyStr] | None = Field(
         None, description="The tasks of the project"
     )
     system_requirements: SystemRequirements | None = Field(
diff --git a/schema/schema.json b/schema/schema.json
index abfdee1873..6df82e515c 100644
--- a/schema/schema.json
+++ b/schema/schema.json
@@ -191,6 +191,12 @@
             {
               "$ref": "#/$defs/TaskInlineTable"
             },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/$defs/DependsOn"
+              }
+            },
             {
               "type": "string",
               "minLength": 1
@@ -728,6 +734,12 @@
                 {
                   "$ref": "#/$defs/TaskInlineTable"
                 },
+                {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/$defs/DependsOn"
+                  }
+                },
                 {
                   "type": "string",
                   "minLength": 1
@@ -1839,7 +1851,7 @@
       "description": "The project's metadata information.",
       "type": "object",
       "required": [
-        "platforms"
+        "channels"
       ],
       "additionalProperties": false,
       "properties": {
diff --git a/schema/test_manifest.py b/schema/test_manifest.py
index e7d99fa87a..2434e6f878 100644
--- a/schema/test_manifest.py
+++ b/schema/test_manifest.py
@@ -8,37 +8,33 @@
 
 HERE = Path(__file__).parent
 EXAMPLES = HERE / "examples"
-VALID = {ex.stem: ex for ex in (EXAMPLES / "valid").glob("*.toml")}
+DOC_EXAMPLES = HERE.joinpath("..", "docs", "source_files", "pixi_tomls")
+VALID = {ex.stem: ex for ex in (EXAMPLES / "valid").glob("*.toml")} | {
+    ex.stem: ex for ex in DOC_EXAMPLES.glob("*.toml")
+}
 INVALID = {ex.stem: ex for ex in (EXAMPLES / "invalid").glob("*.toml")}
 
 
 @pytest.fixture(scope="module", params=VALID)
 def valid_manifest(request) -> str:
-    manifest_name = request.param
-    with open(f"examples/valid/{manifest_name}.toml") as f:
-        manifest = f.read()
+    manifest = VALID[request.param].read_text()
     manifest_toml = tomllib.loads(manifest)
     return manifest_toml
 
 
 @pytest.fixture(scope="module", params=INVALID)
 def invalid_manifest(request) -> str:
-    manifest_name = request.param
-    with open(f"examples/invalid/{manifest_name}.toml") as f:
-        manifest = f.read()
+    manifest = INVALID[request.param].read_text()
     manifest_toml = tomllib.loads(manifest)
     return manifest_toml
 
 
-# @pytest.fixture()
 def _real_manifest_path():
     # Get all `pixi.toml` files from the project
     for manifest in glob.glob("../**/**/pixi.toml"):
         if "invalid" in manifest:
             continue
         yield manifest
-    #     manifest_paths += [manifest]
-    # return manifest_paths
 
 
 @pytest.fixture(params=_real_manifest_path())

From 94402216ca25735abb9b99d6c9f08c158000405a Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 14:41:45 +0200
Subject: [PATCH 36/39] Extend tests

---
 .../pixi_tomls/task_minijinja_filter.toml     | 10 ------
 .../minijinja/task_args/pixi.lock             |  7 ++++
 .../minijinja/task_args/pixi.toml             | 27 +++++++++++++++
 .../__snapshots__/test_docs_examples.ambr     | 25 ++++++++++++++
 tests/integration_python/conftest.py          |  1 +
 .../integration_python/test_docs_examples.py  | 34 +++++++++++++++++++
 6 files changed, 94 insertions(+), 10 deletions(-)
 delete mode 100644 docs/source_files/pixi_tomls/task_minijinja_filter.toml
 create mode 100644 docs/source_files/pixi_workspaces/minijinja/task_args/pixi.lock
 create mode 100644 docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml

diff --git a/docs/source_files/pixi_tomls/task_minijinja_filter.toml b/docs/source_files/pixi_tomls/task_minijinja_filter.toml
deleted file mode 100644
index 946c81e801..0000000000
--- a/docs/source_files/pixi_tomls/task_minijinja_filter.toml
+++ /dev/null
@@ -1,10 +0,0 @@
-
-[workspace]
-channels = ["conda-forge"]
-name = "workspace-name"
-platforms = ["linux-64"]
-# --8<-- [start:tasks]
-[tasks]
-# Convert argument to uppercase
-upper = { cmd = "echo {{ text | upper }}", args = ["text"] }
-# --8<-- [end:tasks]
diff --git a/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.lock b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.lock
new file mode 100644
index 0000000000..0bf9960646
--- /dev/null
+++ b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.lock
@@ -0,0 +1,7 @@
+version: 6
+environments:
+  default:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    packages: {}
+packages: []
diff --git a/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
new file mode 100644
index 0000000000..131dbd9a51
--- /dev/null
+++ b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
@@ -0,0 +1,27 @@
+
+[workspace]
+channels = ["conda-forge"]
+name = "workspace-name"
+platforms = ["linux-64"]
+# --8<-- [start:tasks]
+[tasks]
+# Simple use of a filter
+task1 = { cmd = "echo {{ text | upper }}", args = ["text"] }
+# Use of a filter with a condition and a default value
+task2 = { cmd = "echo {{ text | lower if 'hoi' in (text | lower) }}", args = [
+  { arg = "text", default = "" },
+] }
+# Use of a expression with a filter
+task3 = { cmd = "echo {{ (a + b) | join(\", \") }}", args = [
+  "a",
+  { arg = "b", default = "!" },
+] }
+# Use of the conditional syntax
+task4 = { cmd = """echo {% if "win" in platform  %}windows{% else %}unix{% endif %}""", args = [
+  "platform",
+] }
+# Use of a loop
+task5 = { cmd = "{% for name in names | split %} echo hello {{ name }};{% endfor %}", args = [
+  "names",
+] }
+# --8<-- [end:tasks]
diff --git a/tests/integration_python/__snapshots__/test_docs_examples.ambr b/tests/integration_python/__snapshots__/test_docs_examples.ambr
index afae9664bb..6c9b77ba02 100644
--- a/tests/integration_python/__snapshots__/test_docs_examples.ambr
+++ b/tests/integration_python/__snapshots__/test_docs_examples.ambr
@@ -1,4 +1,29 @@
 # serializer version: 1
+# name: test_doc_pixi_workspaces_minijinja_task_args
+  dict({
+    'task1': '''
+      HOI RUBEN
+  
+    ''',
+    'task2': '''
+      hoi ruben
+  
+    ''',
+    'task3': '''
+      h, o, i, , R, u, b, e, n, !
+  
+    ''',
+    'task4': '''
+      unix
+  
+    ''',
+    'task5': '''
+      hello hoi
+      hello Ruben
+  
+    ''',
+  })
+# ---
 # name: test_doc_pixi_workspaces_pixi_build[advanced_cpp]
   '''
   3
diff --git a/tests/integration_python/conftest.py b/tests/integration_python/conftest.py
index c3aa36fc2f..c8c3d0f90c 100644
--- a/tests/integration_python/conftest.py
+++ b/tests/integration_python/conftest.py
@@ -125,5 +125,6 @@ def completions_channel_1(channels: Path) -> str:
     return channels.joinpath("completions_channel_1").as_uri()
 
 
+@pytest.fixture
 def doc_pixi_workspaces() -> Path:
     return Path(__file__).parents[2].joinpath("docs", "source_files", "pixi_workspaces")
diff --git a/tests/integration_python/test_docs_examples.py b/tests/integration_python/test_docs_examples.py
index 578b9f198b..6b7291d887 100644
--- a/tests/integration_python/test_docs_examples.py
+++ b/tests/integration_python/test_docs_examples.py
@@ -103,3 +103,37 @@ def test_pytorch_documentation_examples(
             [pixi, "install", "--manifest-path", manifest],
             env={"CONDA_OVERRIDE_CUDA": "12.0"},
         )
+
+
+def test_doc_pixi_workspaces_minijinja_task_args(
+    doc_pixi_workspaces: Path, pixi: Path, tmp_pixi_workspace: Path, snapshot: SnapshotAssertion
+) -> None:
+    workspace_dir = doc_pixi_workspaces.joinpath("minijinja", "task_args")
+
+    # Remove existing .pixi folders
+    shutil.rmtree(workspace_dir.joinpath(".pixi"), ignore_errors=True)
+
+    # Copy to workspace
+    shutil.copytree(workspace_dir, tmp_pixi_workspace, dirs_exist_ok=True)
+
+    # Get manifest
+    manifest = get_manifest(tmp_pixi_workspace)
+
+    # Install the environment
+    tasks = (
+        verify_cli_command(
+            [pixi, "task", "list", "--machine-readable", "--manifest-path", manifest],
+        )
+        .stdout.strip()
+        .split(" ")
+    )
+
+    results = {}
+    for task in tasks:
+        output = verify_cli_command(
+            [pixi, "run", "--manifest-path", manifest, task, "hoi Ruben"],
+        ).stdout
+
+        results[task] = output
+
+    assert results == snapshot

From 69507917d87d7236be11c5f18053b078da12955d Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 15:31:57 +0200
Subject: [PATCH 37/39] Update example and snapshot

---
 .../minijinja/task_args/pixi.toml             | 19 ++++++++-----------
 docs/workspace/advanced_tasks.md              |  2 +-
 .../__snapshots__/test_docs_examples.ambr     |  6 +++---
 3 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
index 131dbd9a51..04cf9c15b5 100644
--- a/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
+++ b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
@@ -5,23 +5,20 @@ name = "workspace-name"
 platforms = ["linux-64"]
 # --8<-- [start:tasks]
 [tasks]
-# Simple use of a filter
+# The arg `text`, converted to uppercase, will be printed.
 task1 = { cmd = "echo {{ text | upper }}", args = ["text"] }
-# Use of a filter with a condition and a default value
-task2 = { cmd = "echo {{ text | lower if 'hoi' in (text | lower) }}", args = [
+# If arg `text` contains 'hoi', it will be converted to lowercase. The result will be printed.
+task2 = { cmd = "echo {{ text | lower if 'hoi' in text }}", args = [
   { arg = "text", default = "" },
 ] }
-# Use of a expression with a filter
-task3 = { cmd = "echo {{ (a + b) | join(\", \") }}", args = [
-  "a",
-  { arg = "b", default = "!" },
-] }
-# Use of the conditional syntax
+# With `a` and `b` being strings, they will be appended and then printed.
+task3 = { cmd = "echo {{ a + b }}", args = ["a", { arg = "b", default = "!" }] }
+# If the string "win" is in arg `platform`, "windows" will be printed, otherwise "unix".
 task4 = { cmd = """echo {% if "win" in platform  %}windows{% else %}unix{% endif %}""", args = [
   "platform",
 ] }
-# Use of a loop
-task5 = { cmd = "{% for name in names | split %} echo hello {{ name }};{% endfor %}", args = [
+# `names` will be split by whitespace and then every name will be printed separately
+task5 = { cmd = "{% for name in names | split %} echo {{ name }};{% endfor %}", args = [
   "names",
 ] }
 # --8<-- [end:tasks]
diff --git a/docs/workspace/advanced_tasks.md b/docs/workspace/advanced_tasks.md
index b338547f0c..f1be37b995 100644
--- a/docs/workspace/advanced_tasks.md
+++ b/docs/workspace/advanced_tasks.md
@@ -250,7 +250,7 @@ Basic syntax for using an argument in your command:
 You can also use filters to transform argument values:
 
 ```toml title="pixi.toml"
---8<-- "docs/source_files/pixi_tomls/task_minijinja_filter.toml:tasks"
+--8<-- "docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml:tasks"
 ```
 
 For more information about available filters and template syntax, see the [MiniJinja documentation](https://docs.rs/minijinja/latest/minijinja/filters/index.html).
diff --git a/tests/integration_python/__snapshots__/test_docs_examples.ambr b/tests/integration_python/__snapshots__/test_docs_examples.ambr
index 6c9b77ba02..a25c5fc9e8 100644
--- a/tests/integration_python/__snapshots__/test_docs_examples.ambr
+++ b/tests/integration_python/__snapshots__/test_docs_examples.ambr
@@ -10,7 +10,7 @@
   
     ''',
     'task3': '''
-      h, o, i, , R, u, b, e, n, !
+      hoi Ruben!
   
     ''',
     'task4': '''
@@ -18,8 +18,8 @@
   
     ''',
     'task5': '''
-      hello hoi
-      hello Ruben
+      hoi
+      Ruben
   
     ''',
   })

From d941c6d209de9eaeea0b1499388c2b29966c9900 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 15:45:14 +0200
Subject: [PATCH 38/39] Fix up error type

---
 src/task/executable_task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/task/executable_task.rs b/src/task/executable_task.rs
index 2e45cb26b4..8984a55489 100644
--- a/src/task/executable_task.rs
+++ b/src/task/executable_task.rs
@@ -205,7 +205,7 @@ impl<'p> ExecutableTask<'p> {
     ///
     /// This function returns `None` if the task does not define a command to
     /// execute. This is the case for alias only commands.
-    pub(crate) fn full_command(&self) -> Result<Option<String>, anyhow::Error> {
+    pub(crate) fn full_command(&self) -> Result<Option<String>, TaskStringError> {
         let original_cmd = self
             .task
             .as_single_command(Some(&self.args))?

From 6dea750e03fc8186659184be919ee461eeaa86b0 Mon Sep 17 00:00:00 2001
From: Julian Hofer <julianhofer@gnome.org>
Date: Thu, 17 Apr 2025 16:15:49 +0200
Subject: [PATCH 39/39] Add platforms

---
 docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
index 04cf9c15b5..721d270ca7 100644
--- a/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
+++ b/docs/source_files/pixi_workspaces/minijinja/task_args/pixi.toml
@@ -2,7 +2,7 @@
 [workspace]
 channels = ["conda-forge"]
 name = "workspace-name"
-platforms = ["linux-64"]
+platforms = ["osx-arm64", "osx-64", "linux-64", "win-64"]
 # --8<-- [start:tasks]
 [tasks]
 # The arg `text`, converted to uppercase, will be printed.