nemo-evaluator-launcher 0.1.17__tar.gz → 0.1.19__tar.gz

{nemo_evaluator_launcher-0.1.17 → nemo_evaluator_launcher-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nemo-evaluator-launcher
-Version: 0.1.17
+Version: 0.1.19
 Summary: Launcher for the evaluations provided by NeMo Evaluator containers with different runtime backends
 Author: NVIDIA
 Author-email: nemo-toolkit@nvidia.com

{nemo_evaluator_launcher-0.1.17 → nemo_evaluator_launcher-0.1.19}/src/nemo_evaluator_launcher/__init__.py

@@ -20,6 +20,7 @@ It automatically initializes logging and conditionally loads internal components
 """
 
 import importlib
+import warnings
 
 from nemo_evaluator_launcher.common.logging_utils import logger
 from nemo_evaluator_launcher.package_info import (
@@ -32,9 +33,22 @@ from nemo_evaluator_launcher.package_info import (
     __version__,
 )
 
-logger.info("Version info", pkg=__package_name__, ver=__version__)
+# Suppress pydantic warnings from third-party libraries (e.g., wandb) that are not
+# compatible with Pydantic 2.x field metadata on Python 3.13+
+warnings.filterwarnings(
+    "ignore",
+    message=r"The 'repr' attribute.*Field\(\).*",
+    category=Warning,
+)
+warnings.filterwarnings(
+    "ignore",
+    message=r"The 'frozen' attribute.*Field\(\).*",
+    category=Warning,
+)
 
 
+logger.info("Version info", pkg=__package_name__, ver=__version__)
+
 try:
     importlib.import_module("nemo_evaluator_launcher_internal")
     logger.debug(

{nemo_evaluator_launcher-0.1.17 → nemo_evaluator_launcher-0.1.19}/src/nemo_evaluator_launcher/api/types.py

@@ -19,9 +19,18 @@ This module defines data structures and helpers for configuration and type safet
 """
 
 import os
+import warnings
 from dataclasses import dataclass
 from typing import cast
 
+# ruff: noqa: E402
+# Later when adding optional module to hydra, since the internal package is optional,
+# will generate a hydra warning. We suppress it as distraction and bad UX, before hydra gets invoked.
+warnings.filterwarnings(
+    "ignore",
+    message="provider=hydra.searchpath.*path=nemo_evaluator_launcher_internal.*is not available\\.",
+)
+
 import hydra
 from hydra.core.global_hydra import GlobalHydra
 from omegaconf import DictConfig, OmegaConf

nemo_evaluator_launcher-0.1.17/src/nemo_evaluator_launcher/cli/debug.py → nemo_evaluator_launcher-0.1.19/src/nemo_evaluator_launcher/cli/info.py

@@ -14,16 +14,16 @@
 # limitations under the License.
 #
 
-"""Debugging helper functionalities for nemo-evaluator-launcher."""
+"""Job information helper functionalities for nemo-evaluator-launcher."""
 
+import sys
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Tuple
 
 from simple_parsing import field
 
-from nemo_evaluator_launcher.cli.export import ExportCmd
 from nemo_evaluator_launcher.cli.version import Cmd as VersionCmd
 from nemo_evaluator_launcher.common.execdb import EXEC_DB_FILE, ExecutionDB, JobData
 from nemo_evaluator_launcher.common.logging_utils import logger
@@ -35,52 +35,60 @@ _EXPORT_HELPER = LocalExporter({})
 
 
 @dataclass
-class DebugCmd(ExportCmd):
-    """Debugging functionalities for nemo-evaluator-launcher.
+class InfoCmd:
+    """Job information functionalities for nemo-evaluator-launcher.
 
     Examples:
-      nemo-evaluator-launcher debug <inv>                 # Full debug info
-      nemo-evaluator-launcher debug <inv> --config        # Show stored job config (YAML)
-      nemo-evaluator-launcher debug <inv> --artifacts     # Show artifact locations
-      nemo-evaluator-launcher debug <inv> --logs          # Show log locations
-      nemo-evaluator-launcher debug <inv> --copy-logs <path>       # Copy logs (default: current dir)
-      nemo-evaluator-launcher debug <inv> --copy-artifacts <path>   # Copy artifacts (default: current dir)
+      nemo-evaluator-launcher info <inv>                 # Full job info
+      nemo-evaluator-launcher info <inv> --config        # Show stored job config (YAML)
+      nemo-evaluator-launcher info <inv> --artifacts     # Show artifact locations and key files
+      nemo-evaluator-launcher info <inv> --logs          # Show log locations and key files
+      nemo-evaluator-launcher info <inv> --copy-logs <DIR>       # Copy logs to <DIR>
+      nemo-evaluator-launcher info <inv> --copy-artifacts <DIR>  # Copy artifacts to <DIR>
 
     Notes:
-      - Supports invocation IDs and job IDs
+      - Supports invocation IDs and job IDs (space-separated)
       - Shows local or remote paths depending on executor (local/slurm/lepton)
+      - Copy operations work for both local and remote jobs (expect longer time for remote jobs)
+      - Copy operations are not supported for Lepton executor (yet).
     """
 
-    # local exporter destination defaults to local
-    dest: str = field(default="local", init=False)
+    invocation_ids: List[str] = field(
+        positional=True,
+        help="IDs to show info for (space-separated). Accepts invocation IDs or/and job IDs.",
+    )
 
-    # debug modes
-    config: bool = field(default=False, help="Show job configuration")
-    artifacts: bool = field(default=False, help="Show artifact locations")
-    logs: bool = field(default=False, help="Show log locations")
+    # info modes
+    config: bool = field(
+        default=False, action="store_true", help="Show job configuration"
+    )
+    artifacts: bool = field(
+        default=False, action="store_true", help="Show artifact locations and key files"
+    )
+    logs: bool = field(
+        default=False, action="store_true", help="Show log locations and key files"
+    )
 
-    # copy operations
-    copy_logs: Optional[str] = field(
+    # copy operations - work for both local and remote jobs
+    copy_logs: str | None = field(
         default=None,
         alias=["--copy-logs"],
-        nargs="?",
-        help="Copy logs to local directory (default: current dir)",
+        help="Copy logs to a local directory",
+        metavar="DIR",
     )
-    copy_artifacts: Optional[str] = field(
+    copy_artifacts: str | None = field(
         default=None,
         alias=["--copy-artifacts"],
-        nargs="?",
-        help="Copy artifacts to local directory (default: current dir)",
+        help="Copy artifacts to a local directory",
+        metavar="DIR",
     )
 
     def execute(self) -> None:
-        # show version
         VersionCmd().execute()
-
-        logger.info("Debug command started", invocation_ids=self.invocation_ids)
+        logger.info("Info command started", invocation_ids=self.invocation_ids)
 
         if not self.invocation_ids:
-            logger.error("No invocation IDs provided")
+            logger.error("No job or invocation IDs provided.")
             raise ValueError("No job or invocation IDs provided.")
 
         jobs = self._resolve_jobs()
@@ -96,48 +104,63 @@ class DebugCmd(ExportCmd):
                 "No valid jobs found (jobs may have been deleted or IDs may be incorrect)."
             )
             print(
-                "No valid jobs found (jobs may have been deletedd or IDs may be incorrect)."
+                "No valid jobs found (jobs may have been deleted or IDs may be incorrect)."
             )
             return
 
+        # show ops
         if self.config:
-            logger.info("Showing job configuration", job_count=len(jobs))
             self._show_config_info(jobs)
-        elif self.logs:
-            logger.info("Showing job logs locations", job_count=len(jobs))
+        if self.logs:
             self._show_logs_info(jobs)
-        elif self.artifacts:
-            logger.info("Showing artifacts locations", job_count=len(jobs))
+        if self.artifacts:
             self._show_artifacts_info(jobs)
-        elif self.copy_logs is not None:
-            dest = self.copy_logs or "."
-            if not self.copy_logs:
-                print(
-                    "No destination provided for --copy-logs; defaulting to current dir"
-                )
+
+        # copy ops
+        args = sys.argv[1:]
+        copy_logs_flag = "--copy-logs" in args
+        copy_artifacts_flag = "--copy-artifacts" in args
+
+        if copy_logs_flag:
+            if self.copy_logs is None:
+                raise ValueError("--copy-logs requires a directory path")
+            if not self.copy_logs.strip():
+                raise ValueError("--copy-logs requires a directory path")
             logger.info(
-                "Copying logs to local directory", dest_dir=dest, job_count=len(jobs)
+                "Copying logs to local directory",
+                dest_dir=self.copy_logs,
+                job_count=len(jobs),
             )
-            self._copy_logs(jobs, dest)
-        elif self.copy_artifacts is not None:
-            dest = self.copy_artifacts or "."
-            if not self.copy_artifacts:
-                print(
-                    "No destination provided for --copy-artifacts; defaulting to current dir)"
-                )
+            self._copy_logs(jobs, self.copy_logs)
+
+        if copy_artifacts_flag:
+            if self.copy_artifacts is None:
+                raise ValueError("--copy-artifacts requires a directory path")
+            if not self.copy_artifacts.strip():
+                raise ValueError("--copy-artifacts requires a directory path")
             logger.info(
                 "Copying artifacts to local directory",
-                dest_dir=dest,
+                dest_dir=self.copy_artifacts,
                 job_count=len(jobs),
             )
-            self._copy_artifacts(jobs, dest)
-        else:
+            self._copy_artifacts(jobs, self.copy_artifacts)
+
+        # default view when no flags
+        if not any(
+            [
+                self.config,
+                self.logs,
+                self.artifacts,
+                self.copy_logs,
+                self.copy_artifacts,
+            ]
+        ):
             logger.info(
                 "Job metadata details",
                 invocation_id=jobs[0][1].invocation_id if jobs else None,
                 jobs=len(jobs),
             )
-            self._show_invocation_debug_info(jobs)
+            self._show_invocation_info(jobs)
 
     def _resolve_jobs(self) -> List[Tuple[str, JobData]]:
         """Resolve jobs from ExecDB using IDs (job IDs and/or invocation IDs)."""
@@ -160,15 +183,15 @@ class DebugCmd(ExportCmd):
                 uniq.append((jid, jd))
         return sorted(uniq, key=lambda p: p[0])
 
-    def _show_invocation_debug_info(self, jobs: List[Tuple[str, JobData]]) -> None:
+    def _show_invocation_info(self, jobs: List[Tuple[str, JobData]]) -> None:
         inv = jobs[0][1].invocation_id if jobs else None
-        logger.info("Debug information", jobs=len(jobs), invocation=inv)
+        logger.info("Job information", jobs=len(jobs), invocation=inv)
         print(
-            f"Debug information for {len(jobs)} job(s){f' under invocation {inv}' if inv else ''}:\n"
+            f"Job information for {len(jobs)} job(s){f' under invocation {inv}' if inv else ''}:\n"
         )
 
         for job_id, job_data in jobs:
-            self._show_job_debug_info(job_id, job_data)
+            self._show_job_info(job_id, job_data)
             print()
 
         # footer hint: where to find more metadata
@@ -184,10 +207,14 @@ class DebugCmd(ExportCmd):
         print("  - Use --logs to show log locations.")
         print("  - Use --artifacts to show artifact locations.")
         print("  - Use --config to show stored job configuration (YAML).")
-        print("  - Use --copy-logs [DIR] to copy logs to a local directory.")
-        print("  - Use --copy-artifacts [DIR] to copy artifacts to a local directory.")
+        print(
+            "  - Use --copy-logs [DIR] to copy logs to a local directory (works for local and remote jobs)."
+        )
+        print(
+            "  - Use --copy-artifacts [DIR] to copy artifacts to a local directory (works for local and remote jobs)."
+        )
 
-    def _show_job_debug_info(self, job_id: str, job_data: JobData) -> None:
+    def _show_job_info(self, job_id: str, job_data: JobData) -> None:
         logger.info("Job", job_id=job_id)
         print(f"Job {job_id}")
 
@@ -208,14 +235,22 @@ class DebugCmd(ExportCmd):
             logger.info("Task", job_id=job_id, name=task_name)
             print(f"├── Task: {task_name}")
 
+        # Determine executor type for file descriptions
+        cfg_exec_type = ((job_data.config or {}).get("execution") or {}).get("type")
+        exec_type = (job_data.executor or cfg_exec_type or "").lower()
+
         # locations via exporter helper
         paths = _EXPORT_HELPER.get_job_paths(job_data)
 
-        # Artifacts
+        # Artifacts with file descriptions
+        artifacts_list = _get_artifacts_file_list()
         if paths.get("storage_type") == "remote_ssh":
             artifacts_path = f"{paths['username']}@{paths['hostname']}:{paths['remote_path']}/artifacts"
             logger.info("Artifacts", job_id=job_id, path=artifacts_path, remote=True)
             print(f"├── Artifacts: {artifacts_path} (remote)")
+            print("│   └── Key files:")
+            for filename, desc in artifacts_list:
+                print(f"│       ├── {filename} - {desc}")
         else:
             ap = paths.get("artifacts_dir")
             if ap:
@@ -224,14 +259,21 @@ class DebugCmd(ExportCmd):
                     "Artifacts", job_id=job_id, path=str(ap), exists_indicator=exists
                 )
                 print(f"├── Artifacts: {ap} {exists} (local)")
+                print("│   └── Key files:")
+                for filename, desc in artifacts_list:
+                    print(f"│       ├── {filename} - {desc}")
 
-        # Logs
+        # Logs with file descriptions
+        logs_list = _get_log_file_list(exec_type)
         if paths.get("storage_type") == "remote_ssh":
             logs_path = (
                 f"{paths['username']}@{paths['hostname']}:{paths['remote_path']}/logs"
             )
             logger.info("Logs", job_id=job_id, path=logs_path, remote=True)
             print(f"├── Logs: {logs_path} (remote)")
+            print("│   └── Key files:")
+            for filename, desc in logs_list:
+                print(f"│       ├── {filename} - {desc}")
         else:
             lp = paths.get("logs_dir")
             if lp:
@@ -240,6 +282,9 @@ class DebugCmd(ExportCmd):
                     "Logs", job_id=job_id, path=str(lp), exists_indicator=exists
                 )
                 print(f"├── Logs: {lp} {exists} (local)")
+                print("│   └── Key files:")
+                for filename, desc in logs_list:
+                    print(f"│       ├── {filename} - {desc}")
 
         # executor-specific
         d = job_data.data or {}
@@ -264,17 +309,23 @@ class DebugCmd(ExportCmd):
             eu = d.get("endpoint_url")
             if eu:
                 print(f"├── Endpoint URL: {eu}")
-        # local and others: paths already displayed above; no extra fields needed
 
     def _show_logs_info(self, jobs: List[Tuple[str, JobData]]) -> None:
         logger.info("Log locations")
         print("Log locations:\n")
         for job_id, job_data in jobs:
             paths = _EXPORT_HELPER.get_job_paths(job_data)
+            cfg_exec_type = ((job_data.config or {}).get("execution") or {}).get("type")
+            exec_type = (job_data.executor or cfg_exec_type or "").lower()
+            logs_list = _get_log_file_list(exec_type)
+
             if paths.get("storage_type") == "remote_ssh":
                 logs_path = f"ssh://{paths['username']}@{paths['hostname']}{paths['remote_path']}/logs"
                 logger.info("Logs", job_id=job_id, path=logs_path, remote=True)
                 print(f"{job_id}: {logs_path} (remote)")
+                print("  └── Key files:")
+                for filename, desc in logs_list:
+                    print(f"      ├── {filename} - {desc}")
             else:
                 lp = paths.get("logs_dir")
                 if lp:
@@ -283,18 +334,26 @@ class DebugCmd(ExportCmd):
                         "Logs", job_id=job_id, path=str(lp), exists_indicator=exists
                     )
                     print(f"{job_id}: {lp} {exists} (local)")
+                    print("  └── Key files:")
+                    for filename, desc in logs_list:
+                        print(f"      ├── {filename} - {desc}")
 
     def _show_artifacts_info(self, jobs: List[Tuple[str, JobData]]) -> None:
         logger.info("Artifact locations")
         print("Artifact locations:\n")
         for job_id, job_data in jobs:
             paths = _EXPORT_HELPER.get_job_paths(job_data)
+            artifacts_list = _get_artifacts_file_list()
+
             if paths.get("storage_type") == "remote_ssh":
                 artifacts_path = f"ssh://{paths['username']}@{paths['hostname']}{paths['remote_path']}/artifacts"
                 logger.info(
                     "Artifacts", job_id=job_id, path=artifacts_path, remote=True
                 )
                 print(f"{job_id}: {artifacts_path} (remote)")
+                print("  └── Key files:")
+                for filename, desc in artifacts_list:
+                    print(f"      ├── {filename} - {desc}")
             else:
                 ap = paths.get("artifacts_dir")
                 if ap:
@@ -306,6 +365,9 @@ class DebugCmd(ExportCmd):
                         exists_indicator=exists,
                     )
                     print(f"{job_id}: {ap} {exists} (local)")
+                    print("  └── Key files:")
+                    for filename, desc in artifacts_list:
+                        print(f"      ├── {filename} - {desc}")
 
     def _show_config_info(self, jobs: List[Tuple[str, JobData]]) -> None:
         for job_id, job_data in jobs:
@@ -383,6 +445,9 @@ class DebugCmd(ExportCmd):
                         print(
                             f"{jid}: Failed - {job_result.get('message', 'Unknown error')}"
                         )
+            # Show full destination path
+            full_dest_path = Path(dest_dir).resolve()
+            print(f"Copied to: {full_dest_path}")
         else:
             err = result.get("error", "Unknown error")
             logger.warning("Content copy failed", error=err, dest_dir=dest_dir)
@@ -403,3 +468,45 @@ class DebugCmd(ExportCmd):
         except Exception:
             pass
         return ""
+
+
+# Helper functions for file descriptions (based on actual code and content analysis)
+def _get_artifacts_file_list() -> list[tuple[str, str]]:
+    """Files generated in artifacts/."""
+    return [
+        (
+            "results.yml",
+            "Benchmark scores, task results and resolved run configuration.",
+        ),
+        (
+            "eval_factory_metrics.json",
+            "Response + runtime stats (latency, tokens count, memory)",
+        ),
+        ("metrics.json", "Harness/benchmark metric and configuration"),
+        ("report.html", "Request-Response Pairs samples in HTML format (if enabled)"),
+        ("report.json", "Report data in json format, if enabled"),
+    ]
+
+
+def _get_log_file_list(executor_type: str) -> list[tuple[str, str]]:
+    """Files actually generated in logs/ - executor-specific."""
+    et = (executor_type or "local").lower()
+    if et == "slurm":
+        return [
+            ("client-{SLURM_JOB_ID}.out", "Evaluation container/process output"),
+            (
+                "slurm-{SLURM_JOB_ID}.out",
+                "SLURM scheduler stdout/stderr (batch submission, export steps).",
+            ),
+            (
+                "server-{SLURM_JOB_ID}.out",
+                "Model server logs when a deployment is used.",
+            ),
+        ]
+    # local executor
+    return [
+        (
+            "stdout.log",
+            "Complete evaluation output (timestamps, resolved config, run/export messages).",
+        ),
+    ]

{nemo_evaluator_launcher-0.1.17 → nemo_evaluator_launcher-0.1.19}/src/nemo_evaluator_launcher/cli/main.py

@@ -19,8 +19,8 @@ import os
 
 from simple_parsing import ArgumentParser
 
-import nemo_evaluator_launcher.cli.debug as debug
 import nemo_evaluator_launcher.cli.export as export
+import nemo_evaluator_launcher.cli.info as info
 import nemo_evaluator_launcher.cli.kill as kill
 import nemo_evaluator_launcher.cli.ls_runs as ls_runs
 import nemo_evaluator_launcher.cli.ls_tasks as ls_tasks
@@ -42,12 +42,12 @@ def is_verbose_enabled(args) -> bool:
     subcommands = [
         "run",
         "status",
+        "info",
         "kill",
         "tasks_alias",
         "tasks",
         "runs",
         "export",
-        "debug",
     ]
     for subcmd in subcommands:
         if hasattr(args, subcmd) and hasattr(getattr(args, subcmd), "verbose"):
@@ -163,16 +163,16 @@ def create_parser() -> ArgumentParser:
     )
     export_parser.add_arguments(export.ExportCmd, dest="export")
 
-    # Debug helper subcommand
-    debug_parser = subparsers.add_parser(
-        "debug",
+    # Info subcommand
+    info_parser = subparsers.add_parser(
+        "info",
         help="Display evaluation job information",
-        description="Debug helper functionalities for nemo-evaluator-launcher",
+        description="Info functionalities for nemo-evaluator-launcher",
     )
-    debug_parser.add_argument(
+    info_parser.add_argument(
         "-v", "--verbose", action="store_true", help="Enable verbose logging"
     )
-    debug_parser.add_arguments(debug.DebugCmd, dest="debug")
+    info_parser.add_arguments(info.InfoCmd, dest="info")
 
     return parser
 
@@ -218,8 +218,8 @@ def main() -> None:
             args.runs.execute()
     elif args.command == "export":
         args.export.execute()
-    elif args.command == "debug":
-        args.debug.execute()
+    elif args.command == "info":
+        args.info.execute()
 
 
 if __name__ == "__main__":

{nemo_evaluator_launcher-0.1.17 → nemo_evaluator_launcher-0.1.19}/src/nemo_evaluator_launcher/cli/run.py

@@ -19,6 +19,15 @@ from dataclasses import dataclass
 
 from simple_parsing import field
 
+from nemo_evaluator_launcher.common.logging_utils import logger
+from nemo_evaluator_launcher.common.printing_utils import (
+    bold,
+    cyan,
+    green,
+    magenta,
+    red,
+)
+
 
 @dataclass
 class Cmd:
@@ -101,15 +110,10 @@ class Cmd:
         try:
             invocation_id = run_eval(config, self.dry_run)
         except Exception as e:
-            print(f"\033[31m✗ Job submission failed | Error: {e}\033[0m")
+            print(red(f"✗ Job submission failed, see logs | Error: {e}"))
+            logger.error("Job submission failed", error=e)
             raise
 
-        # Print general success message with invocation ID
-        if invocation_id is not None and not self.dry_run:
-            print(
-                f"\033[32m✓ Job submission successful | Invocation ID: {invocation_id}\033[0m"
-            )
-
         # Save the complete configuration
         if not self.dry_run and invocation_id is not None:
             # Determine config output directory
@@ -151,14 +155,22 @@ class Cmd:
                 f.write("#\n")
                 f.write(config_yaml)
 
-            print(f"Complete run config saved to: {config_path}")
+            print(bold(cyan("Complete run config saved to: ")) + f"\n  {config_path}\n")
+            logger.info("Saved complete config", path=config_path)
 
-        if invocation_id is not None:
-            print(f"to check status: nemo-evaluator-launcher status {invocation_id}")
-            print(f"to kill all jobs: nemo-evaluator-launcher kill {invocation_id}")
+        # Print general success message with invocation ID and helpful commands
+        if invocation_id is not None and not self.dry_run:
+            print(
+                bold(cyan("To check status: "))
+                + f"nemo-evaluator-launcher status {invocation_id}"
+            )
+            print(
+                bold(cyan("To kill all jobs: "))
+                + f"nemo-evaluator-launcher kill {invocation_id}"
+            )
 
             # Show actual job IDs and task names
-            print("to kill individual jobs:")
+            print(bold(cyan("To kill individual jobs:")))
             # Access tasks - will work after normalization in run_eval
             tasks = (
                 config.evaluation.tasks
@@ -168,7 +180,21 @@ class Cmd:
             for idx, task in enumerate(tasks):
                 job_id = f"{invocation_id}.{idx}"
                 print(f"  nemo-evaluator-launcher kill {job_id}  # {task.name}")
+
+            print(
+                magenta(
+                    "(all commands accept shortened IDs as long as there are no conflicts)"
+                )
+            )
             print(
-                "to print all jobs: nemo-evaluator-launcher ls runs"
+                bold(cyan("To print all jobs: ")) + "nemo-evaluator-launcher ls runs"
                 "\n  (--since 1d or --since 6h for time span, see --help)"
             )
+
+            print(
+                green(
+                    bold(
+                        f"✓ Job submission successful | Invocation ID: {invocation_id}"
+                    )
+                )
+            )

{nemo_evaluator_launcher-0.1.17 → nemo_evaluator_launcher-0.1.19}/src/nemo_evaluator_launcher/cli/status.py

@@ -17,6 +17,7 @@ from dataclasses import dataclass
 
 from simple_parsing import field
 
+import nemo_evaluator_launcher.common.printing_utils as pu
 from nemo_evaluator_launcher.executors.base import ExecutionState
 
 
@@ -143,17 +144,17 @@ class Cmd:
         """Format status with Unicode visual indicators only."""
         # Status mapping based on ExecutionState enum
         status_formats = {
-            ExecutionState.SUCCESS.value: "\033[32m✓ SUCCESS\033[0m",  # Green Unicode checkmark
-            ExecutionState.FAILED.value: "\033[31m✗ FAILED\033[0m",  # Red Unicode X
-            ExecutionState.RUNNING.value: "\033[33m▶ RUNNING\033[0m",  # Yellow Unicode play button
-            ExecutionState.PENDING.value: "\033[36m⧗ PENDING\033[0m",  # Cyan Unicode hourglass (U+29D7)
-            ExecutionState.KILLED.value: "\033[35m✗ KILLED\033[0m",  # Magenta Unicode X
+            ExecutionState.SUCCESS.value: pu.green("✓ SUCCESS"),
+            ExecutionState.FAILED.value: pu.red("✗ FAILED"),
+            ExecutionState.RUNNING.value: pu.yellow("▶ RUNNING"),
+            ExecutionState.PENDING.value: pu.cyan("⧗ PENDING"),
+            ExecutionState.KILLED.value: pu.magenta("✗ KILLED"),
             # Additional states for error handling
-            "not_found": "\033[90m? NOT FOUND\033[0m",  # Gray question mark
-            "error": "\033[31m✗ ERROR\033[0m",  # Red Unicode X
+            "not_found": pu.grey("? NOT FOUND"),
+            "error": pu.red("✗ ERROR"),
         }
 
-        return status_formats.get(status.lower(), f"\033[90m? {status.upper()}\033[0m")
+        return status_formats.get(status.lower(), pu.grey(status.upper()))
 
     def _strip_ansi_codes(self, text: str) -> str:
         """Remove ANSI color codes from text for length calculation."""