benchbox 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

benchbox/cli/commands/checks.py

@@ -91,10 +91,7 @@ def check_dependencies(ctx, platform, verbose, show_matrix):
         else:
             console.print(f"[red]❌ {platform} missing dependencies: {', '.join(missing)}[/red]")
             console.print(f"\nExtra: [yellow]{dep_info.name}[/yellow]")
-            console.print("Install with:")
-            console.print(f"  • {dep_info.install_command}")
-            console.print(f'  • python -m pip install "benchbox[{dep_info.name}]"')
-            console.print(f'  • pipx install "benchbox[{dep_info.name}]"')
+            console.print(dep_info.get_install_message())
             console.print("\nNeed help comparing extras? Run: benchbox check-deps --matrix")
 
         if verbose:

benchbox/cli/commands/convert.py

@@ -1,7 +1,7 @@
 """Format conversion command for benchmark data.
 
 This command converts benchmark data between different table formats
-(TBL, Parquet, Delta Lake, Apache Iceberg) for optimized query performance.
+(TBL, Parquet, Vortex, Delta Lake, Apache Iceberg) for optimized query performance.
 """
 
 from __future__ import annotations
@@ -91,7 +91,7 @@ def _get_schemas_from_manifest(manifest: ManifestV2, benchmark_name: str | None)
 @click.option(
     "--format",
     "target_format",
-    type=click.Choice(["parquet", "delta", "iceberg"], case_sensitive=False),
+    type=click.Choice(["parquet", "vortex", "delta", "iceberg", "ducklake"], case_sensitive=False),
     required=True,
     help="Target format for conversion",
 )
@@ -144,7 +144,7 @@ def convert(
     """Convert benchmark data to optimized table formats.
 
     Converts TPC benchmark data from TBL (pipe-delimited) format to columnar
-    formats like Parquet, Delta Lake, or Apache Iceberg. This enables
+    formats like Parquet, Vortex, Delta Lake, or Apache Iceberg. This enables
     significant query performance improvements (2-10x faster).
 
     The command reads the manifest file in the input directory to discover
@@ -155,6 +155,9 @@ def convert(
         # Convert to Parquet with default settings
         benchbox convert --input ./data/tpch_sf1 --format parquet
 
+        # Convert to Vortex for high compression
+        benchbox convert --input ./data/tpch_sf1 --format vortex
+
         # Convert to Delta Lake with Zstd compression
         benchbox convert --input ./data/tpch_sf1 --format delta --compression zstd
 
@@ -175,8 +178,10 @@ def convert(
     \b
     Supported Formats:
         parquet  - Apache Parquet (columnar, compressed)
+        vortex   - Vortex (high compression, fast scans)
         delta    - Delta Lake (ACID transactions, time travel)
         iceberg  - Apache Iceberg (schema evolution, hidden partitioning)
+        ducklake - DuckLake (DuckDB native, ACID transactions, time travel)
 
     \b
     Compression Options:

benchbox/cli/commands/metrics.py

@@ -130,21 +130,54 @@ def qphh(ctx, power_results, throughput_results, scale_factor, output_format, ou
             console.print("[red]Error: Could not auto-detect scale factor. Please specify --scale-factor[/red]")
             sys.exit(1)
 
-    # Extract timing information
-    power_time = power_data.get("results", {}).get("total_execution_time")
-    throughput_time = throughput_data.get("results", {}).get("total_execution_time")
-
-    if not power_time or not throughput_time:
-        console.print("[red]Error: Could not extract execution times from result files[/red]")
-        console.print("Expected 'results.total_execution_time' in both files")
+    # Extract metrics if available (preferred)
+    power_metrics = power_data.get("summary", {}).get("tpc_metrics", {})
+    throughput_metrics = throughput_data.get("summary", {}).get("tpc_metrics", {})
+
+    power_time_ms = power_data.get("summary", {}).get("timing", {}).get("total_ms")
+    throughput_time_ms = throughput_data.get("summary", {}).get("timing", {}).get("total_ms")
+    power_time = (power_time_ms / 1000.0) if power_time_ms else None
+    throughput_time = (throughput_time_ms / 1000.0) if throughput_time_ms else None
+
+    power_at_size = power_metrics.get("power_at_size")
+    throughput_at_size = throughput_metrics.get("throughput_at_size")
+
+    # Fallback: derive metrics from query timings if needed
+    if power_at_size is None or throughput_at_size is None:
+        from benchbox.core.results.metrics import TPCMetricsCalculator
+
+        if power_at_size is None:
+            power_query_times = [
+                q["ms"] / 1000.0
+                for q in power_data.get("queries", [])
+                if q.get("run_type") == "measurement" and q.get("status") == "SUCCESS"
+            ]
+            if power_query_times:
+                power_at_size = TPCMetricsCalculator.calculate_power_at_size(power_query_times, scale_factor)
+
+        if throughput_at_size is None:
+            throughput_summary = throughput_data.get("summary", {}).get("queries", {})
+            total_queries = throughput_summary.get("total")
+            throughput_time_ms = throughput_data.get("summary", {}).get("timing", {}).get("total_ms")
+            if total_queries and throughput_time_ms:
+                num_streams = throughput_data.get("run", {}).get("streams", 1)
+                throughput_at_size = TPCMetricsCalculator.calculate_throughput_at_size(
+                    total_queries,
+                    throughput_time_ms / 1000.0,
+                    scale_factor,
+                    num_streams,
+                )
+
+    if power_at_size is None or throughput_at_size is None:
+        console.print("[red]Error: Could not derive Power@Size or Throughput@Size from result files[/red]")
         sys.exit(1)
 
-    # Extract number of streams for throughput test
-    num_streams = throughput_data.get("environment", {}).get("num_streams", 1)
+    # Extract number of streams for throughput test (best-effort)
+    num_streams = throughput_data.get("run", {}).get("streams") or throughput_data.get("environment", {}).get(
+        "num_streams", 1
+    )
 
-    # Calculate metrics according to TPC-H specification
-    power_at_size = (3600.0 * scale_factor) / power_time
-    throughput_at_size = (num_streams * 3600.0 * scale_factor) / throughput_time
+    # Calculate composite metric according to TPC-H specification
     qphh_at_size = math.sqrt(power_at_size * throughput_at_size)
 
     # Prepare output
@@ -191,8 +224,16 @@ def _format_text_output(result: dict) -> str:
     lines.append("-" * 70)
     lines.append("TEST EXECUTION TIMES")
     lines.append("-" * 70)
-    lines.append(f"Power Test:       {result['power_test_time']:.3f} seconds")
-    lines.append(f"Throughput Test:  {result['throughput_test_time']:.3f} seconds")
+    power_time = result.get("power_test_time")
+    throughput_time = result.get("throughput_test_time")
+    if power_time is not None:
+        lines.append(f"Power Test:       {power_time:.3f} seconds")
+    else:
+        lines.append("Power Test:       n/a")
+    if throughput_time is not None:
+        lines.append(f"Throughput Test:  {throughput_time:.3f} seconds")
+    else:
+        lines.append("Throughput Test:  n/a")
     lines.append("")
     lines.append("-" * 70)
     lines.append("TPC-H METRICS")

benchbox/cli/commands/results.py

@@ -1,11 +1,20 @@
 """Results command implementation."""
 
+import json
+from pathlib import Path
+
 import click
+from pydantic import ValidationError
+from rich.console import Console
+from rich.panel import Panel
 
 from benchbox.cli.output import ResultExporter
+from benchbox.core.schemas import ExecutionContext
+
+console = Console()
 
 
-@click.command("results")
+@click.group("results", invoke_without_command=True)
 @click.option("--limit", type=int, default=10, help="Number of results to show")
 @click.pass_context
 def results(ctx, limit):
@@ -17,9 +26,128 @@ def results(ctx, limit):
     Examples:
         benchbox results              # Show last 10 results
         benchbox results --limit 25   # Show last 25 results
+        benchbox results show-cli <file>  # Show CLI command to reproduce a run
+    """
+    # If no subcommand is invoked, show results summary
+    if ctx.invoked_subcommand is None:
+        exporter = ResultExporter()
+        exporter.show_results_summary()
+
+
+@results.command("show-cli")
+@click.argument("result_file", type=click.Path(exists=True))
+@click.option("--full", is_flag=True, help="Show full command with all options")
+def show_cli(result_file: str, full: bool) -> None:
+    """Reconstruct the CLI command from a benchmark result file.
+
+    Reads a benchmark result JSON file and reconstructs the CLI command
+    that can be used to reproduce the benchmark run.
+
+    Examples:
+        benchbox results show-cli benchmark_runs/results/tpch_sf001_duckdb_20240101_120000.json
+        benchbox results show-cli ./result.json --full
     """
-    exporter = ResultExporter()
-    exporter.show_results_summary()
+    try:
+        result_path = Path(result_file)
+        with result_path.open("r") as f:
+            data = json.load(f)
+
+        # Extract key identifiers
+        platform = None
+        benchmark_name = None
+        scale_factor = None
+        execution_context = None
+
+        # Try schema v2.x format first
+        if "benchmark" in data and isinstance(data["benchmark"], dict):
+            benchmark_name = data["benchmark"].get("name") or data["benchmark"].get("id")
+            scale_factor = data["benchmark"].get("scale_factor")
+
+        if "platform" in data and isinstance(data["platform"], dict):
+            platform = data["platform"].get("name")
+
+        # Try legacy format
+        if not platform:
+            platform = data.get("platform")
+        if not benchmark_name:
+            benchmark_name = data.get("benchmark_name") or data.get("benchmark_id")
+        if not scale_factor:
+            scale_factor = data.get("scale_factor")
+
+        # Get execution context
+        execution_context = data.get("execution") or data.get("execution_context")
+
+        if not all([platform, benchmark_name, scale_factor is not None]):
+            console.print(
+                "[red]❌ Could not extract required fields (platform, benchmark, scale_factor) from result file[/red]"
+            )
+            return
+
+        # Build base command
+        base_cmd = f"benchbox run --platform {platform} --benchmark {benchmark_name} --scale {scale_factor}"
+
+        # If we have execution context, reconstruct full command
+        if execution_context:
+            ctx = ExecutionContext(**{k: v for k, v in execution_context.items() if k != "invocation_timestamp"})
+            cli_args = ctx.to_cli_args()
+            if cli_args:
+                full_cmd = f"{base_cmd} {' '.join(cli_args)}"
+            else:
+                full_cmd = base_cmd
+        else:
+            full_cmd = base_cmd
+            # Try to reconstruct from other fields
+            extra_args = []
+
+            # Query subset from run block
+            if "run" in data and data["run"].get("query_subset"):
+                extra_args.extend(["--queries", ",".join(data["run"]["query_subset"])])
+
+            # Seed
+            if execution_context and execution_context.get("seed"):
+                extra_args.extend(["--seed", str(execution_context["seed"])])
+
+            if extra_args:
+                full_cmd = f"{base_cmd} {' '.join(extra_args)}"
+
+        # Display the command
+        console.print("\n[bold]Reconstructed CLI Command:[/bold]")
+        console.print(Panel(full_cmd, style="green"))
+
+        # Show provenance info
+        if execution_context:
+            entry_point = execution_context.get("entry_point", "unknown")
+            timestamp = execution_context.get("timestamp") or execution_context.get("invocation_timestamp")
+            console.print(f"\n[dim]Entry point: {entry_point}[/dim]")
+            if timestamp:
+                console.print(f"[dim]Executed: {timestamp}[/dim]")
+
+        # If --full flag, show what options were non-default
+        if full and execution_context:
+            console.print("\n[bold]Execution Context Details:[/bold]")
+            for key, value in execution_context.items():
+                if key not in ("invocation_timestamp", "entry_point") and value is not None:
+                    # Skip default values
+                    if key == "phases" and value == ["power"]:
+                        continue
+                    if key == "mode" and value == "sql":
+                        continue
+                    if key == "compression_type" and value == "none":
+                        continue
+                    if key == "compression_enabled" and not value:
+                        continue
+                    if isinstance(value, bool) and not value:
+                        continue
+                    console.print(f"  {key}: {value}")
+
+    except json.JSONDecodeError as e:
+        console.print(f"[red]❌ Invalid JSON file: {e}[/red]")
+    except (FileNotFoundError, PermissionError, IsADirectoryError) as e:
+        console.print(f"[red]❌ Cannot read file: {e}[/red]")
+    except (KeyError, TypeError) as e:
+        console.print(f"[red]❌ Invalid result file format: {e}[/red]")
+    except ValidationError as e:
+        console.print(f"[red]❌ Invalid execution context in result file: {e}[/red]")
 
 
 __all__ = ["results"]

benchbox/cli/commands/run.py

@@ -52,6 +52,7 @@ from benchbox.cli.tuning_resolver import (
 )
 from benchbox.core.config import DatabaseConfig
 from benchbox.core.platform_registry import PlatformRegistry
+from benchbox.core.schemas import ExecutionContext
 from benchbox.platforms import is_dataframe_platform, list_available_dataframe_platforms
 from benchbox.utils.cloud_storage import is_cloud_path
 from benchbox.utils.compression import CompressionManager
@@ -86,6 +87,59 @@ def normalize_benchmark_name(name: str) -> str:
     return BENCHMARK_ALIASES.get(normalized, normalized)
 
 
+def _build_execution_context(
+    phases_to_run: list[str],
+    seed: int | None,
+    compression: CompressionConfig,
+    mode: str | None,
+    official: bool,
+    validation: ValidationConfig,
+    force: ForceConfig,
+    queries_to_run: list[str] | None,
+    capture_plans: bool,
+    strict_plan_capture: bool,
+    non_interactive: bool,
+    tuning: str | None,
+) -> ExecutionContext:
+    """Build ExecutionContext from CLI parameters for result reproducibility.
+
+    Args:
+        phases_to_run: List of phases to execute
+        seed: Random seed for query generation
+        compression: Compression configuration
+        mode: Execution mode (sql/dataframe)
+        official: TPC-compliant mode flag
+        validation: Validation configuration
+        force: Force flags configuration
+        queries_to_run: Query subset
+        capture_plans: Whether to capture query plans
+        strict_plan_capture: Strict plan capture mode
+        non_interactive: Non-interactive mode flag
+        tuning: Tuning mode/path
+
+    Returns:
+        ExecutionContext populated from CLI parameters
+    """
+    return ExecutionContext(
+        entry_point="cli",
+        phases=phases_to_run,
+        seed=seed,
+        compression_enabled=compression.enabled,
+        compression_type=compression.type,
+        compression_level=compression.level,
+        mode=mode or "sql",
+        official=official,
+        validation_mode=validation.mode if validation.mode != "exact" else None,
+        force_datagen=force.datagen,
+        force_upload=force.upload,
+        query_subset=queries_to_run,
+        capture_plans=capture_plans,
+        strict_plan_capture=strict_plan_capture,
+        non_interactive=non_interactive,
+        tuning_mode=tuning if tuning and tuning != "notuning" else None,
+    )
+
+
 class PlatformOptionParamType(click.ParamType):
     """Click parameter type for key=value platform options."""
 
@@ -307,7 +361,7 @@ def setup_verbose_logging(
     "--convert",
     type=CONVERT,
     default=None,
-    help="Convert format: parquet, delta:snappy, iceberg:zstd,partition:year,month",
+    help="Convert format: parquet, vortex, delta:snappy, iceberg:zstd,partition:year,month",
 )
 # Validation
 @advanced_option(
@@ -447,14 +501,6 @@ def run(
                 "[yellow]⚠️  Warning: No --seed specified. Official TPC runs require a random seed for reproducibility.[/yellow]"
             )
 
-        # Validate throughput phase requires streams (not implemented yet, but warn)
-        phase_list = [p.strip().lower() for p in phases.split(",")]
-        if "throughput" in phase_list:
-            console.print(
-                "[yellow]⚠️  Note: Throughput test requires multiple concurrent streams. "
-                "Multi-stream support is not yet implemented.[/yellow]"
-            )
-
         # Show compliance banner
         console.print("[bold blue]TPC-Compliant Official Benchmark Run[/bold blue]")
         console.print(f"Scale Factor: {scale} (TPC-allowed)")
@@ -996,7 +1042,7 @@ def run(
             console.print("[yellow]Use values like 0.1, 0.01, 0.001, etc. for small scale factors[/yellow]")
             if logger:
                 logger.error(f"Invalid scale factor for dry run: {scale}")
-            return
+            ctx.exit(1)
 
         # Create configurations for dry run
         if logger:
@@ -1014,7 +1060,7 @@ def run(
             console.print(f"Available benchmarks: {', '.join(bench_manager.benchmarks.keys())}")
             if logger:
                 logger.error(f"Unknown benchmark: {benchmark}. Available: {list(bench_manager.benchmarks.keys())}")
-            return
+            ctx.exit(1)
 
         # Create database config (skip for data-only mode)
         if execution_mode == "data_only":
@@ -1072,7 +1118,7 @@ def run(
             console.print(f"[red]❌ {e}[/red]")
             if logger:
                 logger.error(f"Scale factor validation failed: {e}")
-            return
+            ctx.exit(1)
 
         benchmark_config = BenchmarkConfig(
             name=benchmark,
@@ -1226,7 +1272,7 @@ def run(
             console.print(f"[red]❌ {e}[/red]")
             if logger:
                 logger.error(f"Scale factor validation failed: {e}")
-            return
+            ctx.exit(1)
 
         # Create benchmark config
         benchmark_config = BenchmarkConfig(
@@ -1261,6 +1307,22 @@ def run(
         profiler = SystemProfiler()
         system_profile = profiler.get_system_profile()
 
+        # Build execution context for reproducibility
+        execution_context = _build_execution_context(
+            phases_to_run=phases_to_run,
+            seed=seed,
+            compression=comp_config,
+            mode=mode,
+            official=official,
+            validation=val_config,
+            force=force_config,
+            queries_to_run=queries_to_run,
+            capture_plans=capture_plans,
+            strict_plan_capture=strict_plan_capture,
+            non_interactive=non_interactive,
+            tuning=tuning,
+        )
+
         # Execute benchmark using orchestrator
         orchestrator = BenchmarkOrchestrator()
         orchestrator.set_verbosity(verbosity_settings)
@@ -1283,12 +1345,22 @@ def run(
             )
             with progress:
                 result = orchestrator.execute_benchmark(
-                    benchmark_config, system_profile, database_config, phases_to_run, progress=progress
+                    benchmark_config,
+                    system_profile,
+                    database_config,
+                    phases_to_run,
+                    progress=progress,
+                    execution_context=execution_context,
                 )
         else:
             # No progress bars - use simple text output
             result = orchestrator.execute_benchmark(
-                benchmark_config, system_profile, database_config, phases_to_run, progress=None
+                benchmark_config,
+                system_profile,
+                database_config,
+                phases_to_run,
+                progress=None,
+                execution_context=execution_context,
             )
 
         # Export results if successful
@@ -1300,7 +1372,7 @@ def run(
 
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             result_path = orchestrator.directory_manager.get_result_path(
-                benchmark, scale, platform.lower(), timestamp, result.execution_id
+                benchmark, scale, platform.lower(), timestamp, result.execution_id, mode=resolved_mode
             )
 
             # Export to the organized directory
@@ -1421,7 +1493,7 @@ def run(
             console.print(f"[red]❌ {e}[/red]")
             if logger:
                 logger.error(f"Scale factor validation failed: {e}")
-            return
+            ctx.exit(1)
 
         benchmark_config = BenchmarkConfig(
             name=benchmark,
@@ -1452,6 +1524,22 @@ def run(
         profiler = SystemProfiler()
         system_profile = profiler.get_system_profile()
 
+        # Build execution context for reproducibility
+        execution_context = _build_execution_context(
+            phases_to_run=phases_to_run,
+            seed=seed,
+            compression=comp_config,
+            mode=mode,
+            official=official,
+            validation=val_config,
+            force=force_config,
+            queries_to_run=queries_to_run,
+            capture_plans=capture_plans,
+            strict_plan_capture=strict_plan_capture,
+            non_interactive=non_interactive,
+            tuning=tuning,
+        )
+
         # Execute using orchestrator
         orchestrator = BenchmarkOrchestrator()
         orchestrator.set_verbosity(verbosity_settings)
@@ -1479,19 +1567,40 @@ def run(
             )
             with progress:
                 result = orchestrator.execute_benchmark(
-                    benchmark_config, system_profile, database_config, phases_to_run, progress=progress
+                    benchmark_config,
+                    system_profile,
+                    database_config,
+                    phases_to_run,
+                    progress=progress,
+                    execution_context=execution_context,
                 )
         else:
             # No progress bars - use simple text output
             result = orchestrator.execute_benchmark(
-                benchmark_config, system_profile, database_config, phases_to_run, progress=None
+                benchmark_config,
+                system_profile,
+                database_config,
+                phases_to_run,
+                progress=None,
+                execution_context=execution_context,
             )
 
         # Export results if successful
         if result.validation_status not in ["FAILED", "INTERRUPTED"]:
             console.print("\n[bold]Exporting results...[/bold]")
+            from datetime import datetime
+
             exporter = ResultExporter()
             export_formats = ["json"]  # Default format for command-line execution
+
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            platform_label = platform.lower() if platform else "unknown"
+            mode_label = "data_only" if execution_mode == "data_only" else resolved_mode
+            result_path = orchestrator.directory_manager.get_result_path(
+                benchmark, scale, platform_label, timestamp, result.execution_id, mode=mode_label
+            )
+            result.output_filename = result_path.name
+
             exported_files = exporter.export_result(result, export_formats)
 
             # Determine actual status from execution phases, not validation status
@@ -1635,7 +1744,7 @@ def run(
                 console.print(f"[red]❌ {e}[/red]")
                 if logger:
                     logger.error(f"Scale factor validation failed: {e}")
-                return
+                ctx.exit(1)
 
             benchmark_config = BenchmarkConfig(
                 name=benchmark,
@@ -1972,6 +2081,22 @@ def run(
     console.print("\n[bold]Step 6 of 6:[/bold] [cyan]Benchmark Execution[/cyan]")
     console.print("Executing benchmark with platform optimizations...")
 
+    # Build execution context for reproducibility
+    execution_context = _build_execution_context(
+        phases_to_run=phases_to_run,
+        seed=seed,
+        compression=comp_config,
+        mode=mode,
+        official=official,
+        validation=val_config,
+        force=force_config,
+        queries_to_run=queries_to_run,
+        capture_plans=capture_plans,
+        strict_plan_capture=strict_plan_capture,
+        non_interactive=non_interactive,
+        tuning=tuning,
+    )
+
     # Use orchestrator for better execution
     orchestrator = BenchmarkOrchestrator()
     orchestrator.set_verbosity(verbosity_settings)
@@ -1994,12 +2119,22 @@ def run(
         )
         with progress:
             result = orchestrator.execute_benchmark(
-                benchmark_config, system_profile, database_config, phases_to_run, progress=progress
+                benchmark_config,
+                system_profile,
+                database_config,
+                phases_to_run,
+                progress=progress,
+                execution_context=execution_context,
             )
     else:
         # No progress bars - use simple text output
         result = orchestrator.execute_benchmark(
-            benchmark_config, system_profile, database_config, phases_to_run, progress=None
+            benchmark_config,
+            system_profile,
+            database_config,
+            phases_to_run,
+            progress=None,
+            execution_context=execution_context,
         )
 
     # Export results

benchbox/cli/commands/visualize.py

@@ -33,9 +33,9 @@ SUPPORTED_CHART_TYPES = ("performance_bar", "distribution_box", "query_heatmap",
     "--format",
     "formats",
     multiple=True,
-    default=("png", "html"),
+    default=("html",),
     show_default=True,
-    help="Export formats (png, svg, pdf, html).",
+    help="Export formats (html only; raster formats planned for future).",
 )
 @click.option(
     "--chart-type",
@@ -92,7 +92,7 @@ def visualize(
         console.print(f"[red]Error:[/red] {exc}")
         ctx.exit(1)
 
-    formats = tuple(formats) if formats else ("png", "html")
+    formats = tuple(formats) if formats else ("html",)
     chosen_chart_types: list[str] | None = None
 
     if template_name:

benchbox/cli/composite_params.py

@@ -214,7 +214,7 @@ class ConvertConfig:
             config.format = format_part.lower()
 
         # Validate format
-        valid_formats = ("parquet", "delta", "iceberg")
+        valid_formats = ("parquet", "vortex", "delta", "iceberg")
         if config.format not in valid_formats:
             raise click.BadParameter(f"Invalid format '{config.format}'. Valid formats: {', '.join(valid_formats)}")
 

benchbox/cli/config.py

@@ -875,10 +875,19 @@ class DirectoryManager:
         platform: str,
         timestamp: str,
         execution_id: str,
+        mode: str | None = None,
     ) -> str:
         """Generate standardized result filename."""
-        sf_str = self._format_scale_factor(scale_factor)
-        return f"{benchmark_name}_{sf_str}_{platform}_{timestamp}_{execution_id}.json"
+        from benchbox.core.results.filenames import build_result_filename
+
+        return build_result_filename(
+            benchmark_id=benchmark_name,
+            scale_factor=scale_factor,
+            platform=platform,
+            timestamp=timestamp,
+            execution_id=execution_id,
+            mode=mode,
+        )
 
     def get_result_path(
         self,
@@ -887,9 +896,10 @@ class DirectoryManager:
         platform: str,
         timestamp: str,
         execution_id: str,
+        mode: str | None = None,
     ) -> Path:
         """Get full path for result file."""
-        filename = self.get_result_filename(benchmark_name, scale_factor, platform, timestamp, execution_id)
+        filename = self.get_result_filename(benchmark_name, scale_factor, platform, timestamp, execution_id, mode=mode)
         return self.results_dir / filename
 
     def get_database_filename(