tasktree 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

tasktree/executor.py

@@ -14,15 +14,24 @@ from pathlib import Path
 from typing import Any
 
 from tasktree import docker as docker_module
-from tasktree.graph import get_implicit_inputs, resolve_execution_order, resolve_dependency_output_references, resolve_self_references
+from tasktree.graph import (
+    get_implicit_inputs,
+    resolve_execution_order,
+    resolve_dependency_output_references,
+    resolve_self_references,
+)
 from tasktree.hasher import hash_args, hash_task, make_cache_key
 from tasktree.parser import Recipe, Task, Environment
 from tasktree.state import StateManager, TaskState
+from tasktree.hasher import hash_environment_definition
 
 
 @dataclass
 class TaskStatus:
-    """Status of a task for execution planning."""
+    """
+    Status of a task for execution planning.
+    @athena: a718e784981d
+    """
 
     task_name: str
     will_run: bool
@@ -33,45 +42,56 @@ class TaskStatus:
 
 
 class ExecutionError(Exception):
-    """Raised when task execution fails."""
+    """
+    Raised when task execution fails.
+    @athena: f22d72903ee4
+    """
 
     pass
 
 
 class Executor:
-    """Executes tasks with incremental execution logic."""
+    """
+    Executes tasks with incremental execution logic.
+    @athena: 88e82151721d
+    """
 
     # Protected environment variables that cannot be overridden by exported args
     PROTECTED_ENV_VARS = {
-        'PATH',
-        'LD_LIBRARY_PATH',
-        'LD_PRELOAD',
-        'PYTHONPATH',
-        'HOME',
-        'SHELL',
-        'USER',
-        'LOGNAME',
+        "PATH",
+        "LD_LIBRARY_PATH",
+        "LD_PRELOAD",
+        "PYTHONPATH",
+        "HOME",
+        "SHELL",
+        "USER",
+        "LOGNAME",
     }
 
     def __init__(self, recipe: Recipe, state_manager: StateManager):
-        """Initialize executor.
+        """
+        Initialize executor.
 
         Args:
-            recipe: Parsed recipe containing all tasks
-            state_manager: State manager for tracking task execution
+        recipe: Parsed recipe containing all tasks
+        state_manager: State manager for tracking task execution
+        @athena: 21b65db48bca
         """
         self.recipe = recipe
         self.state = state_manager
         self.docker_manager = docker_module.DockerManager(recipe.project_root)
 
-    def _has_regular_args(self, task: Task) -> bool:
-        """Check if a task has any regular (non-exported) arguments.
+    @staticmethod
+    def _has_regular_args(task: Task) -> bool:
+        """
+        Check if a task has any regular (non-exported) arguments.
 
         Args:
-            task: Task to check
+        task: Task to check
 
         Returns:
-            True if task has at least one regular (non-exported) argument, False otherwise
+        True if task has at least one regular (non-exported) argument, False otherwise
+        @athena: a4c7816bfe61
         """
         if not task.args:
             return False
@@ -81,26 +101,29 @@ class Executor:
             # Handle both string and dict arg specs
             if isinstance(arg_spec, str):
                 # Remove default value part if present
-                arg_name = arg_spec.split('=')[0].split(':')[0].strip()
-                if not arg_name.startswith('$'):
+                arg_name = arg_spec.split("=")[0].split(":")[0].strip()
+                if not arg_name.startswith("$"):
                     return True
             elif isinstance(arg_spec, dict):
                 # Dict format: { argname: { ... } } or { $argname: { ... } }
                 for key in arg_spec.keys():
-                    if not key.startswith('$'):
+                    if not key.startswith("$"):
                         return True
 
         return False
 
-    def _filter_regular_args(self, task: Task, task_args: dict[str, Any]) -> dict[str, Any]:
-        """Filter task_args to only include regular (non-exported) arguments.
+    @staticmethod
+    def _filter_regular_args(task: Task, task_args: dict[str, Any]) -> dict[str, Any]:
+        """
+        Filter task_args to only include regular (non-exported) arguments.
 
         Args:
-            task: Task definition
-            task_args: Dictionary of all task arguments
+        task: Task definition
+        task_args: Dictionary of all task arguments
 
         Returns:
-            Dictionary containing only regular (non-exported) arguments
+        Dictionary containing only regular (non-exported) arguments
+        @athena: 974e5e32bbd7
         """
         if not task.args or not task_args:
             return {}
@@ -109,55 +132,55 @@ class Executor:
         exported_names = set()
         for arg_spec in task.args:
             if isinstance(arg_spec, str):
-                arg_name = arg_spec.split('=')[0].split(':')[0].strip()
-                if arg_name.startswith('$'):
+                arg_name = arg_spec.split("=")[0].split(":")[0].strip()
+                if arg_name.startswith("$"):
                     exported_names.add(arg_name[1:])  # Remove $ prefix
             elif isinstance(arg_spec, dict):
                 for key in arg_spec.keys():
-                    if key.startswith('$'):
+                    if key.startswith("$"):
                         exported_names.add(key[1:])  # Remove $ prefix
 
         # Filter out exported args
         return {k: v for k, v in task_args.items() if k not in exported_names}
 
-    def _collect_early_builtin_variables(self, task: Task, timestamp: datetime) -> dict[str, str]:
-        """Collect built-in variables that don't depend on working_dir.
+    def _collect_early_builtin_variables(
+        self, task: Task, timestamp: datetime
+    ) -> dict[str, str]:
+        """
+        Collect built-in variables that don't depend on working_dir.
 
         These variables can be used in the working_dir field itself.
 
         Args:
-            task: Task being executed
-            timestamp: Timestamp when task started execution
+        task: Task being executed
+        timestamp: Timestamp when task started execution
 
         Returns:
-            Dictionary mapping built-in variable names to their string values
+        Dictionary mapping built-in variable names to their string values
 
         Raises:
-            ExecutionError: If any built-in variable fails to resolve
+        ExecutionError: If any built-in variable fails to resolve
+        @athena: 3b4c0ec70ad7
         """
         import os
 
-        builtin_vars = {}
-
-        # {{ tt.project_root }} - Absolute path to project root
-        builtin_vars['project_root'] = str(self.recipe.project_root.resolve())
-
-        # {{ tt.recipe_dir }} - Absolute path to directory containing the recipe file
-        builtin_vars['recipe_dir'] = str(self.recipe.recipe_path.parent.resolve())
-
-        # {{ tt.task_name }} - Name of currently executing task
-        builtin_vars['task_name'] = task.name
-
-        # {{ tt.timestamp }} - ISO8601 timestamp when task started execution
-        builtin_vars['timestamp'] = timestamp.strftime('%Y-%m-%dT%H:%M:%SZ')
-
-        # {{ tt.timestamp_unix }} - Unix epoch timestamp when task started
-        builtin_vars['timestamp_unix'] = str(int(timestamp.timestamp()))
+        builtin_vars = {
+            # {{ tt.project_root }} - Absolute path to project root
+            "project_root": str(self.recipe.project_root.resolve()),
+            # {{ tt.recipe_dir }} - Absolute path to directory containing the recipe file
+            "recipe_dir": str(self.recipe.recipe_path.parent.resolve()),
+            # {{ tt.task_name }} - Name of currently executing task
+            "task_name": task.name,
+            # {{ tt.timestamp }} - ISO8601 timestamp when task started execution
+            "timestamp": timestamp.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            # {{ tt.timestamp_unix }} - Unix epoch timestamp when task started
+            "timestamp_unix": str(int(timestamp.timestamp())),
+        }
 
         # {{ tt.user_home }} - Current user's home directory (cross-platform)
         try:
             user_home = Path.home()
-            builtin_vars['user_home'] = str(user_home)
+            builtin_vars["user_home"] = str(user_home)
         except Exception as e:
             raise ExecutionError(
                 f"Failed to get user home directory for {{ tt.user_home }}: {e}"
@@ -168,45 +191,55 @@ class Executor:
             user_name = os.getlogin()
         except OSError:
             # Fallback to environment variables if os.getlogin() fails
-            user_name = os.environ.get('USER') or os.environ.get('USERNAME') or 'unknown'
-        builtin_vars['user_name'] = user_name
+            user_name = (
+                os.environ.get("USER") or os.environ.get("USERNAME") or "unknown"
+            )
+        builtin_vars["user_name"] = user_name
 
         return builtin_vars
 
-    def _collect_builtin_variables(self, task: Task, working_dir: Path, timestamp: datetime) -> dict[str, str]:
-        """Collect built-in variables for task execution.
+    def _collect_builtin_variables(
+        self, task: Task, working_dir: Path, timestamp: datetime
+    ) -> dict[str, str]:
+        """
+        Collect built-in variables for task execution.
 
         Args:
-            task: Task being executed
-            working_dir: Resolved working directory for the task
-            timestamp: Timestamp when task started execution
+        task: Task being executed
+        working_dir: Resolved working directory for the task
+        timestamp: Timestamp when task started execution
 
         Returns:
-            Dictionary mapping built-in variable names to their string values
+        Dictionary mapping built-in variable names to their string values
 
         Raises:
-            ExecutionError: If any built-in variable fails to resolve
+        ExecutionError: If any built-in variable fails to resolve
+        @athena: bb8c385cb0a5
         """
         # Get early builtin vars (those that don't depend on working_dir)
         builtin_vars = self._collect_early_builtin_variables(task, timestamp)
 
         # {{ tt.working_dir }} - Absolute path to task's effective working directory
         # This is added after working_dir is resolved to avoid circular dependency
-        builtin_vars['working_dir'] = str(working_dir.resolve())
+        builtin_vars["working_dir"] = str(working_dir.resolve())
 
         return builtin_vars
 
-    def _prepare_env_with_exports(self, exported_env_vars: dict[str, str] | None = None) -> dict[str, str]:
-        """Prepare environment with exported arguments.
+    def _prepare_env_with_exports(
+        self, exported_env_vars: dict[str, str] | None = None
+    ) -> dict[str, str]:
+        """
+        Prepare environment with exported arguments.
 
         Args:
-            exported_env_vars: Exported arguments to set as environment variables
+        exported_env_vars: Exported arguments to set as environment variables
 
         Returns:
-            Environment dict with exported args merged
+        Environment dict with exported args merged
 
         Raises:
-            ValueError: If an exported arg attempts to override a protected environment variable
+        ValueError: If an exported arg attempts to override a protected environment variable
+        @athena: 5340be771194
         """
         env = os.environ.copy()
         if exported_env_vars:
@@ -220,20 +253,24 @@ class Executor:
             env.update(exported_env_vars)
         return env
 
-    def _get_platform_default_environment(self) -> tuple[str, list[str]]:
-        """Get default shell and args for current platform.
+    @staticmethod
+    def _get_platform_default_environment() -> tuple[str, list[str]]:
+        """
+        Get default shell and args for current platform.
 
         Returns:
-            Tuple of (shell, args) for platform default
+        Tuple of (shell, args) for platform default
+        @athena: 8b7fa81073af
         """
         is_windows = platform.system() == "Windows"
         if is_windows:
-            return ("cmd", ["/c"])
+            return "cmd", ["/c"]
         else:
-            return ("bash", ["-c"])
+            return "bash", ["-c"]
 
     def _get_effective_env_name(self, task: Task) -> str:
-        """Get the effective environment name for a task.
+        """
+        Get the effective environment name for a task.
 
         Resolution order:
         1. Recipe's global_env_override (from CLI --env)
@@ -242,10 +279,11 @@ class Executor:
         4. Empty string (for platform default)
 
         Args:
-            task: Task to get environment name for
+        task: Task to get environment name for
 
         Returns:
-            Environment name (empty string if using platform default)
+        Environment name (empty string if using platform default)
+        @athena: e5bface8a3a2
         """
         # Check for global override first
         if self.recipe.global_env_override:
@@ -262,8 +300,9 @@ class Executor:
         # Platform default (no env name)
         return ""
 
-    def _resolve_environment(self, task: Task) -> tuple[str, list[str], str]:
-        """Resolve which environment to use for a task.
+    def _resolve_environment(self, task: Task) -> tuple[str, str]:
+        """
+        Resolve which environment to use for a task.
 
         Resolution order:
         1. Recipe's global_env_override (from CLI --env)
@@ -272,10 +311,11 @@ class Executor:
         4. Platform default (bash on Unix, cmd on Windows)
 
         Args:
-            task: Task to resolve environment for
+        task: Task to resolve environment for
 
         Returns:
-            Tuple of (shell, args, preamble)
+        Tuple of (shell, preamble)
+        @athena: 15cad76d7c80
         """
         # Check for global override first
         env_name = self.recipe.global_env_override
@@ -292,12 +332,12 @@ class Executor:
         if env_name:
             env = self.recipe.get_environment(env_name)
             if env:
-                return (env.shell, env.args, env.preamble)
+                return env.shell, env.preamble
             # If env not found, fall through to platform default
 
         # Use platform default
-        shell, args = self._get_platform_default_environment()
-        return (shell, args, "")
+        shell, _ = self._get_platform_default_environment()
+        return shell, ""
 
     def check_task_status(
         self,
@@ -305,7 +345,8 @@ class Executor:
         args_dict: dict[str, Any],
         force: bool = False,
     ) -> TaskStatus:
-        """Check if a task needs to run.
+        """
+        Check if a task needs to run.
 
         A task executes if ANY of these conditions are met:
         1. Force flag is set (--force)
@@ -318,12 +359,13 @@ class Executor:
         8. Different arguments than any cached execution
 
         Args:
-            task: Task to check
-            args_dict: Arguments for this task execution
-            force: If True, ignore freshness and force execution
+        task: Task to check
+        args_dict: Arguments for this task execution
+        force: If True, ignore freshness and force execution
 
         Returns:
-            TaskStatus indicating whether task will run and why
+        TaskStatus indicating whether task will run and why
+        @athena: 7252f5db8a4d
         """
         # If force flag is set, always run
         if force:
@@ -335,7 +377,14 @@ class Executor:
 
         # Compute hashes (include effective environment and dependencies)
         effective_env = self._get_effective_env_name(task)
-        task_hash = hash_task(task.cmd, task.outputs, task.working_dir, task.args, effective_env, task.deps)
+        task_hash = hash_task(
+            task.cmd,
+            task.outputs,
+            task.working_dir,
+            task.args,
+            effective_env,
+            task.deps,
+        )
         args_hash = hash_args(args_dict) if args_dict else None
         cache_key = make_cache_key(task_hash, args_hash)
 
@@ -404,19 +453,21 @@ class Executor:
         force: bool = False,
         only: bool = False,
     ) -> dict[str, TaskStatus]:
-        """Execute a task and its dependencies.
+        """
+        Execute a task and its dependencies.
 
         Args:
-            task_name: Name of task to execute
-            args_dict: Arguments to pass to the task
-            force: If True, ignore freshness and re-run all tasks
-            only: If True, run only the specified task without dependencies (implies force=True)
+        task_name: Name of task to execute
+        args_dict: Arguments to pass to the task
+        force: If True, ignore freshness and re-run all tasks
+        only: If True, run only the specified task without dependencies (implies force=True)
 
         Returns:
-            Dictionary of task names to their execution status
+        Dictionary of task names to their execution status
 
         Raises:
-            ExecutionError: If task execution fails
+        ExecutionError: If task execution fails
+        @athena: 1c293ee6a6fa
         """
         if args_dict is None:
             args_dict = {}
@@ -456,13 +507,20 @@ class Executor:
             # Only include regular (non-exported) args in status key for parameterized dependencies
             # For the root task (invoked from CLI), status key is always just the task name
             # For dependencies with parameterized invocations, include the regular args
-            is_root_task = (name == task_name)
-            if not is_root_task and args_dict_for_execution and self._has_regular_args(task):
+            is_root_task = name == task_name
+            if (
+                not is_root_task
+                and args_dict_for_execution
+                and self._has_regular_args(task)
+            ):
                 import json
+
                 # Filter to only include regular (non-exported) args
                 regular_args = self._filter_regular_args(task, args_dict_for_execution)
                 if regular_args:
-                    args_str = json.dumps(regular_args, sort_keys=True, separators=(",", ":"))
+                    args_str = json.dumps(
+                        regular_args, sort_keys=True, separators=(",", ":")
+                    )
                     status_key = f"{name}({args_str})"
                 else:
                     status_key = name
@@ -475,6 +533,7 @@ class Executor:
                 # Warn if re-running due to missing outputs
                 if status.reason == "outputs_missing":
                     import sys
+
                     print(
                         f"Warning: Re-running task '{name}' because declared outputs are missing",
                         file=sys.stderr,
@@ -485,14 +544,16 @@ class Executor:
         return statuses
 
     def _run_task(self, task: Task, args_dict: dict[str, Any]) -> None:
-        """Execute a single task.
+        """
+        Execute a single task.
 
         Args:
-            task: Task to execute
-            args_dict: Arguments to substitute in command
+        task: Task to execute
+        args_dict: Arguments to substitute in command
 
         Raises:
-            ExecutionError: If task execution fails
+        ExecutionError: If task execution fails
+        @athena: 4b49652a7afd
         """
         # Capture timestamp at task start for consistency (in UTC)
         task_start_time = datetime.now(timezone.utc)
@@ -500,6 +561,7 @@ class Executor:
         # Parse task arguments to identify exported args
         # Note: args_dict already has defaults applied by CLI (cli.py:413-424)
         from tasktree.parser import parse_arg_spec
+
         exported_args = set()
         regular_args = {}
         exported_env_vars = {}
@@ -518,18 +580,24 @@ class Executor:
 
         # Collect early built-in variables (those that don't depend on working_dir)
         # These can be used in the working_dir field itself
-        early_builtin_vars = self._collect_early_builtin_variables(task, task_start_time)
+        early_builtin_vars = self._collect_early_builtin_variables(
+            task, task_start_time
+        )
 
         # Resolve working directory
         # Validate that working_dir doesn't contain {{ tt.working_dir }} (circular dependency)
         self._validate_no_working_dir_circular_ref(task.working_dir)
         working_dir_str = self._substitute_builtin(task.working_dir, early_builtin_vars)
-        working_dir_str = self._substitute_args(working_dir_str, regular_args, exported_args)
+        working_dir_str = self._substitute_args(
+            working_dir_str, regular_args, exported_args
+        )
         working_dir_str = self._substitute_env(working_dir_str)
         working_dir = self.recipe.project_root / working_dir_str
 
         # Collect all built-in variables (including tt.working_dir now that it's resolved)
-        builtin_vars = self._collect_builtin_variables(task, working_dir, task_start_time)
+        builtin_vars = self._collect_builtin_variables(
+            task, working_dir, task_start_time
+        )
 
         # Substitute built-in variables, arguments, and environment variables in command
         cmd = self._substitute_builtin(task.cmd, builtin_vars)
@@ -550,69 +618,43 @@ class Executor:
             # Docker execution path
             self._run_task_in_docker(task, env, cmd, working_dir, exported_env_vars)
         else:
-            # Regular execution path
-            shell, shell_args, preamble = self._resolve_environment(task)
-
-            # Detect multi-line commands (ignore trailing newlines from YAML folded blocks)
-            if "\n" in cmd.rstrip():
-                self._run_multiline_command(cmd, working_dir, task.name, shell, preamble, exported_env_vars)
-            else:
-                self._run_single_line_command(cmd, working_dir, task.name, shell, shell_args, exported_env_vars)
+            # Regular execution path - use unified script-based execution
+            shell, preamble = self._resolve_environment(task)
+            self._run_command_as_script(
+                cmd, working_dir, task.name, shell, preamble, exported_env_vars
+            )
 
         # Update state
         self._update_state(task, args_dict)
 
-    def _run_single_line_command(
-        self, cmd: str, working_dir: Path, task_name: str, shell: str, shell_args: list[str],
-        exported_env_vars: dict[str, str] | None = None
+    def _run_command_as_script(
+        self,
+        cmd: str,
+        working_dir: Path,
+        task_name: str,
+        shell: str,
+        preamble: str,
+        exported_env_vars: dict[str, str] | None = None,
     ) -> None:
-        """Execute a single-line command via shell.
-
-        Args:
-            cmd: Command string
-            working_dir: Working directory
-            task_name: Task name (for error messages)
-            shell: Shell executable to use
-            shell_args: Arguments to pass to shell
-            exported_env_vars: Exported arguments to set as environment variables
-
-        Raises:
-            ExecutionError: If command execution fails
         """
-        # Prepare environment with exported args
-        env = self._prepare_env_with_exports(exported_env_vars)
+        Execute a command via temporary script file (unified execution path).
 
-        try:
-            # Build command: shell + args + cmd
-            full_cmd = [shell] + shell_args + [cmd]
-            subprocess.run(
-                full_cmd,
-                cwd=working_dir,
-                check=True,
-                capture_output=False,
-                env=env,
-            )
-        except subprocess.CalledProcessError as e:
-            raise ExecutionError(
-                f"Task '{task_name}' failed with exit code {e.returncode}"
-            )
-
-    def _run_multiline_command(
-        self, cmd: str, working_dir: Path, task_name: str, shell: str, preamble: str,
-        exported_env_vars: dict[str, str] | None = None
-    ) -> None:
-        """Execute a multi-line command via temporary script file.
+        This method handles both single-line and multi-line commands by writing
+        them to a temporary script file and executing the script. This provides
+        consistent behavior and allows preamble to work with all commands.
 
         Args:
-            cmd: Multi-line command string
-            working_dir: Working directory
-            task_name: Task name (for error messages)
-            shell: Shell to use for script execution
-            preamble: Preamble text to prepend to script
-            exported_env_vars: Exported arguments to set as environment variables
+        cmd: Command string (single-line or multi-line)
+        working_dir: Working directory
+        task_name: Task name (for error messages)
+        shell: Shell to use for script execution
+        preamble: Preamble text to prepend to script
+        exported_env_vars: Exported arguments to set as environment variables
 
         Raises:
-            ExecutionError: If command execution fails
+        ExecutionError: If command execution fails
+        @athena: TBD
+        @athena: 96e85dc15b5c
         """
         # Prepare environment with exported args
         env = self._prepare_env_with_exports(exported_env_vars)
@@ -670,45 +712,71 @@ class Executor:
             except OSError:
                 pass  # Ignore cleanup errors
 
-    def _substitute_builtin_in_environment(self, env: Environment, builtin_vars: dict[str, str]) -> Environment:
-        """Substitute builtin and environment variables in environment fields.
+    def _substitute_builtin_in_environment(
+        self, env: Environment, builtin_vars: dict[str, str]
+    ) -> Environment:
+        """
+        Substitute builtin and environment variables in environment fields.
 
         Args:
-            env: Environment to process
-            builtin_vars: Built-in variable values
+        env: Environment to process
+        builtin_vars: Built-in variable values
 
         Returns:
-            New Environment with builtin and environment variables substituted
+        New Environment with builtin and environment variables substituted
 
         Raises:
-            ValueError: If builtin variable or environment variable is not defined
+        ValueError: If builtin variable or environment variable is not defined
+        @athena: 21e2ccd27dbb
         """
         from dataclasses import replace
 
         # Substitute in volumes (builtin vars first, then env vars)
-        substituted_volumes = [
-            self._substitute_env(self._substitute_builtin(vol, builtin_vars)) for vol in env.volumes
-        ] if env.volumes else []
+        substituted_volumes = (
+            [
+                self._substitute_env(self._substitute_builtin(vol, builtin_vars))
+                for vol in env.volumes
+            ]
+            if env.volumes
+            else []
+        )
 
         # Substitute in env_vars values (builtin vars first, then env vars)
-        substituted_env_vars = {
-            key: self._substitute_env(self._substitute_builtin(value, builtin_vars))
-            for key, value in env.env_vars.items()
-        } if env.env_vars else {}
+        substituted_env_vars = (
+            {
+                key: self._substitute_env(self._substitute_builtin(value, builtin_vars))
+                for key, value in env.env_vars.items()
+            }
+            if env.env_vars
+            else {}
+        )
 
         # Substitute in ports (builtin vars first, then env vars)
-        substituted_ports = [
-            self._substitute_env(self._substitute_builtin(port, builtin_vars)) for port in env.ports
-        ] if env.ports else []
+        substituted_ports = (
+            [
+                self._substitute_env(self._substitute_builtin(port, builtin_vars))
+                for port in env.ports
+            ]
+            if env.ports
+            else []
+        )
 
         # Substitute in working_dir (builtin vars first, then env vars)
-        substituted_working_dir = self._substitute_env(self._substitute_builtin(env.working_dir, builtin_vars)) if env.working_dir else ""
+        substituted_working_dir = (
+            self._substitute_env(
+                self._substitute_builtin(env.working_dir, builtin_vars)
+            )
+            if env.working_dir
+            else ""
+        )
 
         # Substitute in build args (for Docker environments, args is a dict)
         # Apply builtin vars first, then env vars
         if isinstance(env.args, dict):
             substituted_args = {
-                key: self._substitute_env(self._substitute_builtin(str(value), builtin_vars))
+                key: self._substitute_env(
+                    self._substitute_builtin(str(value), builtin_vars)
+                )
                 for key, value in env.args.items()
             }
         else:
@@ -721,28 +789,36 @@ class Executor:
             env_vars=substituted_env_vars,
             ports=substituted_ports,
             working_dir=substituted_working_dir,
-            args=substituted_args
+            args=substituted_args,
         )
 
     def _run_task_in_docker(
-        self, task: Task, env: Any, cmd: str, working_dir: Path,
-        exported_env_vars: dict[str, str] | None = None
+        self,
+        task: Task,
+        env: Any,
+        cmd: str,
+        working_dir: Path,
+        exported_env_vars: dict[str, str] | None = None,
     ) -> None:
-        """Execute task inside Docker container.
+        """
+        Execute task inside Docker container.
 
         Args:
-            task: Task to execute
-            env: Docker environment configuration
-            cmd: Command to execute
-            working_dir: Host working directory
-            exported_env_vars: Exported arguments to set as environment variables
+        task: Task to execute
+        env: Docker environment configuration
+        cmd: Command to execute
+        working_dir: Host working directory
+        exported_env_vars: Exported arguments to set as environment variables
 
         Raises:
-            ExecutionError: If Docker execution fails
+        ExecutionError: If Docker execution fails
+        @athena: fe972e4c97a3
         """
         # Get builtin variables for substitution in environment fields
         task_start_time = datetime.now(timezone.utc)
-        builtin_vars = self._collect_builtin_variables(task, working_dir, task_start_time)
+        builtin_vars = self._collect_builtin_variables(
+            task, working_dir, task_start_time
+        )
 
         # Substitute builtin variables in environment fields (volumes, env_vars, etc.)
         env = self._substitute_builtin_in_environment(env, builtin_vars)
@@ -766,6 +842,7 @@ class Executor:
 
         # Create modified environment with merged env vars using dataclass replace
         from dataclasses import replace
+
         modified_env = replace(env, env_vars=docker_env_vars)
 
         # Execute in container
@@ -779,91 +856,111 @@ class Executor:
         except docker_module.DockerError as e:
             raise ExecutionError(str(e)) from e
 
-    def _validate_no_working_dir_circular_ref(self, text: str) -> None:
-        """Validate that working_dir field does not contain {{ tt.working_dir }}.
+    @staticmethod
+    def _validate_no_working_dir_circular_ref(text: str) -> None:
+        """
+        Validate that working_dir field does not contain {{ tt.working_dir }}.
 
         Using {{ tt.working_dir }} in the working_dir field creates a circular dependency.
 
         Args:
-            text: The working_dir field value to validate
+        text: The working_dir field value to validate
 
         Raises:
-            ExecutionError: If {{ tt.working_dir }} placeholder is found
+        ExecutionError: If {{ tt.working_dir }} placeholder is found
+        @athena: 617a0c609f4d
         """
         import re
+
         # Pattern to match {{ tt.working_dir }} specifically
-        pattern = re.compile(r'\{\{\s*tt\s*\.\s*working_dir\s*\}\}')
+        pattern = re.compile(r"\{\{\s*tt\s*\.\s*working_dir\s*}}")
 
         if pattern.search(text):
             raise ExecutionError(
-                f"Cannot use {{{{ tt.working_dir }}}} in the 'working_dir' field.\n\n"
-                f"This creates a circular dependency (working_dir cannot reference itself).\n"
-                f"Other built-in variables like {{{{ tt.task_name }}}} or {{{{ tt.timestamp }}}} are allowed."
+                "Cannot use {{ tt.working_dir }} in the 'working_dir' field.\n\n"
+                "This creates a circular dependency (working_dir cannot reference itself).\n"
+                "Other built-in variables like {{ tt.task_name }} or {{ tt.timestamp }} are allowed."
             )
 
-    def _substitute_builtin(self, text: str, builtin_vars: dict[str, str]) -> str:
-        """Substitute {{ tt.name }} placeholders in text.
+    @staticmethod
+    def _substitute_builtin(text: str, builtin_vars: dict[str, str]) -> str:
+        """
+        Substitute {{ tt.name }} placeholders in text.
 
         Built-in variables are resolved at execution time.
 
         Args:
-            text: Text with {{ tt.name }} placeholders
-            builtin_vars: Built-in variable values
+        text: Text with {{ tt.name }} placeholders
+        builtin_vars: Built-in variable values
 
         Returns:
-            Text with built-in variables substituted
+        Text with built-in variables substituted
 
         Raises:
-            ValueError: If built-in variable is not defined
+        ValueError: If built-in variable is not defined
+        @athena: fe47afe87b52
         """
         from tasktree.substitution import substitute_builtin_variables
+
         return substitute_builtin_variables(text, builtin_vars)
 
-    def _substitute_args(self, cmd: str, args_dict: dict[str, Any], exported_args: set[str] | None = None) -> str:
-        """Substitute {{ arg.name }} placeholders in command string.
+    @staticmethod
+    def _substitute_args(
+        cmd: str, args_dict: dict[str, Any], exported_args: set[str] | None = None
+    ) -> str:
+        """
+        Substitute {{ arg.name }} placeholders in command string.
 
         Variables are already substituted at parse time by the parser.
         This only handles runtime argument substitution.
 
         Args:
-            cmd: Command with {{ arg.name }} placeholders
-            args_dict: Argument values to substitute (only regular args)
-            exported_args: Set of argument names that are exported (not available for substitution)
+        cmd: Command with {{ arg.name }} placeholders
+        args_dict: Argument values to substitute (only regular args)
+        exported_args: Set of argument names that are exported (not available for substitution)
 
         Returns:
-            Command with arguments substituted
+        Command with arguments substituted
 
         Raises:
-            ValueError: If an exported argument is used in template substitution
+        ValueError: If an exported argument is used in template substitution
+        @athena: 9a931179f270
         """
         from tasktree.substitution import substitute_arguments
+
         return substitute_arguments(cmd, args_dict, exported_args)
 
-    def _substitute_env(self, text: str) -> str:
-        """Substitute {{ env.NAME }} placeholders in text.
+    @staticmethod
+    def _substitute_env(text: str) -> str:
+        """
+        Substitute {{ env.NAME }} placeholders in text.
 
         Environment variables are resolved at execution time from os.environ.
 
         Args:
-            text: Text with {{ env.NAME }} placeholders
+        text: Text with {{ env.NAME }} placeholders
 
         Returns:
-            Text with environment variables substituted
+        Text with environment variables substituted
 
         Raises:
-            ValueError: If environment variable is not set
+        ValueError: If environment variable is not set
+        @athena: 1bbe24759451
         """
         from tasktree.substitution import substitute_environment
+
         return substitute_environment(text)
 
     def _get_all_inputs(self, task: Task) -> list[str]:
-        """Get all inputs for a task (explicit + implicit from dependencies).
+        """
+        Get all inputs for a task (explicit + implicit from dependencies).
 
         Args:
-            task: Task to get inputs for
+        task: Task to get inputs for
 
         Returns:
-            List of input glob patterns
+        List of input glob patterns
+        @athena: ca7ed7a6682f
         """
         # Extract paths from inputs (handle both anonymous strings and named dicts)
         all_inputs = []
@@ -878,21 +975,24 @@ class Executor:
         all_inputs.extend(implicit_inputs)
         return all_inputs
 
+    # TODO: Understand why task isn't used
     def _check_environment_changed(
         self, task: Task, cached_state: TaskState, env_name: str
     ) -> bool:
-        """Check if environment definition has changed since last run.
+        """
+        Check if environment definition has changed since last run.
 
         For shell environments: checks YAML definition hash
         For Docker environments: checks YAML hash AND Docker image ID
 
         Args:
-            task: Task to check
-            cached_state: Cached state from previous run
-            env_name: Effective environment name (from _get_effective_env_name)
+        task: Task to check
+        cached_state: Cached state from previous run
+        env_name: Effective environment name (from _get_effective_env_name)
 
         Returns:
-            True if environment definition changed, False otherwise
+        True if environment definition changed, False otherwise
+        @athena: 052561b75455
         """
         # If using platform default (no environment), no definition to track
         if not env_name:
@@ -931,23 +1031,25 @@ class Executor:
     def _check_docker_image_changed(
         self, env: Environment, cached_state: TaskState, env_name: str
     ) -> bool:
-        """Check if Docker image ID has changed.
+        """
+        Check if Docker image ID has changed.
 
         Builds the image and compares the resulting image ID with the cached ID.
         This detects changes from unpinned base images, network-dependent builds, etc.
 
         Args:
-            env: Docker environment definition
-            cached_state: Cached state from previous run
-            env_name: Environment name
+        env: Docker environment definition
+        cached_state: Cached state from previous run
+        env_name: Environment name
 
         Returns:
-            True if image ID changed, False otherwise
+        True if image ID changed, False otherwise
+        @athena: 0443710cf356
         """
         # Build/ensure image is built and get its ID
         try:
             image_tag, current_image_id = self.docker_manager.ensure_image_built(env)
-        except Exception as e:
+        except Exception:
             # If we can't build, treat as changed (will fail later with better error)
             return True
 
@@ -965,7 +1067,8 @@ class Executor:
     def _check_inputs_changed(
         self, task: Task, cached_state: TaskState, all_inputs: list[str]
     ) -> list[str]:
-        """Check if any input files have changed since last run.
+        """
+        Check if any input files have changed since last run.
 
         Handles both regular file inputs and Docker-specific inputs:
         - Regular files: checked via mtime
@@ -973,12 +1076,13 @@ class Executor:
         - Dockerfile digests: checked via parsing and comparison
 
         Args:
-            task: Task to check
-            cached_state: Cached state from previous run
-            all_inputs: All input glob patterns
+        task: Task to check
+        cached_state: Cached state from previous run
+        all_inputs: All input glob patterns
 
         Returns:
-            List of changed file paths
+        List of changed file paths
+        @athena: 15b13fd181bf
         """
         changed_files = []
 
@@ -1038,7 +1142,9 @@ class Executor:
 
                         # Check if digests changed
                         if current_digests != cached_digests:
-                            changed_files.append(f"Docker base image digests in {dockerfile_name}")
+                            changed_files.append(
+                                f"Docker base image digests in {dockerfile_name}"
+                            )
                     except (OSError, IOError):
                         # Can't read Dockerfile - consider changed
                         changed_files.append(f"Dockerfile: {dockerfile_name}")
@@ -1058,14 +1164,17 @@ class Executor:
 
         return changed_files
 
-    def _expand_output_paths(self, task: Task) -> list[str]:
-        """Extract all output paths from task outputs (both named and anonymous).
+    @staticmethod
+    def _expand_output_paths(task: Task) -> list[str]:
+        """
+        Extract all output paths from task outputs (both named and anonymous).
 
         Args:
-            task: Task with outputs to extract
+        task: Task with outputs to extract
 
         Returns:
-            List of output path patterns (glob patterns as strings)
+        List of output path patterns (glob patterns as strings)
+        @athena: 21da23ad5dcf
         """
         paths = []
         for output in task.outputs:
@@ -1078,13 +1187,15 @@ class Executor:
         return paths
 
     def _check_outputs_missing(self, task: Task) -> list[str]:
-        """Check if any declared outputs are missing.
+        """
+        Check if any declared outputs are missing.
 
         Args:
-            task: Task to check
+        task: Task to check
 
         Returns:
-            List of output patterns that have no matching files
+        List of output patterns that have no matching files
+        @athena: 9ceac49b4e68
         """
         if not task.outputs:
             return []
@@ -1104,14 +1215,16 @@ class Executor:
         return missing_patterns
 
     def _expand_globs(self, patterns: list[str], working_dir: str) -> list[str]:
-        """Expand glob patterns to actual file paths.
+        """
+        Expand glob patterns to actual file paths.
 
         Args:
-            patterns: List of glob patterns
-            working_dir: Working directory to resolve patterns from
+        patterns: List of glob patterns
+        working_dir: Working directory to resolve patterns from
 
         Returns:
-            List of file paths (relative to working_dir)
+        List of file paths (relative to working_dir)
+        @athena: 5ba093866558
         """
         files = []
         base_path = self.recipe.project_root / working_dir
@@ -1128,25 +1241,44 @@ class Executor:
         return files
 
     def _update_state(self, task: Task, args_dict: dict[str, Any]) -> None:
-        """Update state after task execution.
-
-        Args:
-            task: Task that was executed
-            args_dict: Arguments used for execution
         """
-        # Compute hashes (include effective environment and dependencies)
+        Update state after task execution.
+        @athena: 1fcfdfcb9be9
+        """
+        cache_key = self._cache_key(task, args_dict)
+        input_state = self._input_files_to_modified_times(task)
+
+        env_name = self._get_effective_env_name(task)
+        if env_name:
+            env = self.recipe.get_environment(env_name)
+            if env:
+                input_state[f"_env_hash_{env_name}"] = hash_environment_definition(env)
+                if env.dockerfile:
+                    input_state |= self._docker_inputs_to_modified_times(env_name, env)
+
+        new_state = TaskState(last_run=time.time(), input_state=input_state)
+        self.state.set(cache_key, new_state)
+        self.state.save()
+
+    def _cache_key(self, task: Task, args_dict: dict[str, Any]) -> str:
         effective_env = self._get_effective_env_name(task)
-        task_hash = hash_task(task.cmd, task.outputs, task.working_dir, task.args, effective_env, task.deps)
+        task_hash = hash_task(
+            task.cmd,
+            task.outputs,
+            task.working_dir,
+            task.args,
+            effective_env,
+            task.deps,
+        )
         args_hash = hash_args(args_dict) if args_dict else None
-        cache_key = make_cache_key(task_hash, args_hash)
+        return make_cache_key(task_hash, args_hash)
 
-        # Get all inputs and their current mtimes
-        all_inputs = self._get_all_inputs(task)
-        input_files = self._expand_globs(all_inputs, task.working_dir)
+    def _input_files_to_modified_times(self, task: Task) -> dict[str, float]:
+        input_files = self._expand_globs(self._get_all_inputs(task), task.working_dir)
 
         input_state = {}
         for file_path in input_files:
-            # Skip Docker special markers (handled separately below)
+            # Skip Docker special markers (handled separately)
             if file_path.startswith("_docker_"):
                 continue
 
@@ -1154,59 +1286,44 @@ class Executor:
             if file_path_obj.exists():
                 input_state[file_path] = file_path_obj.stat().st_mtime
 
-        # Record Docker-specific inputs if task uses Docker environment
-        env_name = self._get_effective_env_name(task)
-        if env_name:
-            env = self.recipe.get_environment(env_name)
-            if env and env.dockerfile:
-                # Record Dockerfile mtime
-                dockerfile_path = self.recipe.project_root / env.dockerfile
-                if dockerfile_path.exists():
-                    input_state[env.dockerfile] = dockerfile_path.stat().st_mtime
-
-                # Record .dockerignore mtime if exists
-                context_path = self.recipe.project_root / env.context
-                dockerignore_path = context_path / ".dockerignore"
-                if dockerignore_path.exists():
-                    relative_dockerignore = str(
-                        dockerignore_path.relative_to(self.recipe.project_root)
-                    )
-                    input_state[relative_dockerignore] = dockerignore_path.stat().st_mtime
-
-                # Record context check timestamp
-                input_state[f"_context_{env.context}"] = time.time()
-
-                # Parse and record base image digests from Dockerfile
-                try:
-                    dockerfile_content = dockerfile_path.read_text()
-                    digests = docker_module.parse_base_image_digests(dockerfile_content)
-                    for digest in digests:
-                        # Store digest with Dockerfile's mtime
-                        input_state[f"_digest_{digest}"] = dockerfile_path.stat().st_mtime
-                except (OSError, IOError):
-                    # If we can't read Dockerfile, skip digest tracking
-                    pass
-
-            # Record environment definition hash for all environments (shell and Docker)
-            if env:
-                from tasktree.hasher import hash_environment_definition
-
-                env_hash = hash_environment_definition(env)
-                input_state[f"_env_hash_{env_name}"] = env_hash
+        return input_state
+
+    def _docker_inputs_to_modified_times(
+        self, env_name: str, env: Environment
+    ) -> dict[str, float]:
+        input_state = dict()
+        # Record Dockerfile mtime
+        dockerfile_path = self.recipe.project_root / env.dockerfile
+        if dockerfile_path.exists():
+            input_state[env.dockerfile] = dockerfile_path.stat().st_mtime
+
+        # Record .dockerignore mtime if exists
+        context_path = self.recipe.project_root / env.context
+        dockerignore_path = context_path / ".dockerignore"
+        if dockerignore_path.exists():
+            relative_dockerignore = str(
+                dockerignore_path.relative_to(self.recipe.project_root)
+            )
+            input_state[relative_dockerignore] = dockerignore_path.stat().st_mtime
 
-                # For Docker environments, also store the image ID
-                if env.dockerfile:
-                    # Image was already built during check phase or task execution
-                    if env_name in self.docker_manager._built_images:
-                        image_tag, image_id = self.docker_manager._built_images[env_name]
-                        input_state[f"_docker_image_id_{env_name}"] = image_id
-
-        # Create new state
-        state = TaskState(
-            last_run=time.time(),
-            input_state=input_state,
-        )
+        # Record context check timestamp
+        input_state[f"_context_{env.context}"] = time.time()
 
-        # Save state
-        self.state.set(cache_key, state)
-        self.state.save()
+        # Parse and record base image digests from Dockerfile
+        try:
+            dockerfile_content = dockerfile_path.read_text()
+            digests = docker_module.parse_base_image_digests(dockerfile_content)
+            for digest in digests:
+                # Store digest with Dockerfile's mtime
+                input_state[f"_digest_{digest}"] = dockerfile_path.stat().st_mtime
+        except (OSError, IOError):
+            # If we can't read Dockerfile, skip digest tracking
+            pass
+
+        # For Docker environments, also store the image ID
+        # Image was already built during check phase or task execution
+        if env_name in self.docker_manager._built_images:
+            image_tag, image_id = self.docker_manager._built_images[env_name]
+            input_state[f"_docker_image_id_{env_name}"] = image_id
+
+        return input_state