wafer-cli 0.2.30__py3-none-any.whl → 0.2.31__py3-none-any.whl

wafer/baseline.py

@@ -0,0 +1,661 @@
+"""Baseline CLI commands.
+
+Discover what kernel PyTorch dispatches to for a given operation.
+Helps understand the baseline performance you need to beat.
+"""
+
+import asyncio
+
+import typer
+
+from wafer_core.tools.dispatch_baseline.client import (
+    lookup_baseline,
+    store_baseline,
+)
+from wafer_core.tools.dispatch_baseline.codegen import (
+    parse_op_string,
+    update_dtypes,
+    update_shapes,
+)
+from wafer_core.tools.dispatch_baseline.dtypes import KernelTraceConfig
+from wafer_core.tools.dispatch_baseline.executor import trace_kernel_local
+from wafer_core.tools.dispatch_baseline.roofline import HARDWARE_SPECS, get_hardware_spec
+
+baseline_app = typer.Typer(
+    help="""Discover what kernel PyTorch dispatches to for a given operation.
+
+This helps you understand the baseline performance you need to beat when writing
+custom kernels. Run a PyTorch op, profile it, and see:
+- What kernel PyTorch uses (cuBLAS, cuDNN, Triton, etc.)
+- How fast it runs
+- What % of peak hardware performance it achieves
+
+Results are stored in a shared database - once traced, everyone benefits.
+
+Examples:
+    # Run baseline trace
+    wafer baseline run "torch.matmul(A, B)" -s A=4096,4096 -s B=4096,4096 --target b200-dev
+
+    # Show supported hardware
+    wafer baseline hardware"""
+)
+
+
+def _parse_shape(shape_str: str) -> tuple[str, tuple[int, ...]]:
+    """Parse shape string like 'A=4096,4096' into (name, shape)."""
+    if "=" not in shape_str:
+        raise typer.BadParameter(f"Invalid shape format: {shape_str}. Expected: name=dim1,dim2,...")
+
+    name, dims_str = shape_str.split("=", 1)
+    try:
+        dims = tuple(int(d.strip()) for d in dims_str.split(","))
+    except ValueError:
+        raise typer.BadParameter(f"Invalid dimensions in shape: {dims_str}")
+
+    return name.strip(), dims
+
+
+def _complete_target_name(incomplete: str) -> list[str]:
+    """Autocomplete target names from ~/.wafer/targets/*.toml"""
+    from pathlib import Path
+
+    targets_dir = Path.home() / ".wafer" / "targets"
+    if not targets_dir.exists():
+        return []
+    return [f.stem for f in targets_dir.glob("*.toml") if f.stem.startswith(incomplete)]
+
+
+@baseline_app.command("run")
+def baseline_run_cmd(
+    op: str = typer.Argument(
+        ...,
+        help='PyTorch operation to trace, e.g., "torch.matmul(A, B)"',
+    ),
+    shape: list[str] = typer.Option(
+        [],
+        "--shape",
+        "-s",
+        help="Tensor shape as name=dim1,dim2,... (can specify multiple)",
+    ),
+    dtype: str = typer.Option(
+        "float16",
+        "--dtype",
+        "-d",
+        help="Data type for tensors (float16, float32, bfloat16, etc.)",
+    ),
+    hardware: str = typer.Option(
+        None,
+        "--hardware",
+        help="Hardware name for roofline analysis (auto-detected from target if not specified)",
+    ),
+    target: str = typer.Option(
+        None,
+        "--target",
+        "-t",
+        help="GPU target name (see 'wafer config targets list')",
+        autocompletion=_complete_target_name,
+    ),
+    workspace: str = typer.Option(
+        None,
+        "--workspace",
+        "-w",
+        help="Workspace name (see 'wafer workspaces list')",
+    ),
+    num_warmup: int = typer.Option(
+        10,
+        "--warmup",
+        help="Number of warmup iterations",
+    ),
+    num_runs: int = typer.Option(
+        100,
+        "--runs",
+        help="Number of profiling runs",
+    ),
+    no_cache: bool = typer.Option(
+        False,
+        "--no-cache",
+        help="Skip cache and always run fresh trace",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output as JSON for programmatic use",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show verbose output including raw profiler data",
+    ),
+    timeout: int = typer.Option(
+        120,
+        "--timeout",
+        help="Timeout in seconds for profiling (default: 120)",
+    ),
+) -> None:
+    """Discover what kernel PyTorch dispatches to for a given operation.
+
+    This runs the operation on your GPU with profiling and reports:
+    - Which kernel(s) PyTorch dispatches to
+    - Duration of each kernel
+    - Library that provides the kernel (cuBLAS, cuDNN, etc.)
+    - Roofline analysis (% of peak compute/memory bandwidth)
+
+    Examples:
+        # Run on a target
+        wafer baseline run "torch.matmul(A, B)" -s A=4096,4096 -s B=4096,4096 --target b200-dev
+
+        # Run on a workspace
+        wafer baseline run "torch.matmul(A, B)" -s A=4096,4096 -s B=4096,4096 --workspace cutlass-b200-eval
+
+        # Run locally (requires local GPU)
+        wafer baseline run "torch.matmul(A, B)" -s A=4096,4096 -s B=4096,4096
+
+        # With specific hardware for roofline
+        wafer baseline run "torch.matmul(A, B)" -s A=4096,4096 -s B=4096,4096 --target b200-dev --hardware B200
+    """
+    # Validate mutually exclusive options
+    if target and workspace:
+        typer.echo("Error: Cannot specify both --target and --workspace", err=True)
+        raise typer.Exit(1)
+
+    # Dispatch to appropriate execution mode
+    if target:
+        asyncio.run(_run_on_target(
+            op, shape, dtype, hardware, target, num_warmup, num_runs, no_cache, json_output, verbose, timeout
+        ))
+    elif workspace:
+        asyncio.run(_run_on_workspace(
+            op, shape, dtype, hardware, workspace, num_warmup, num_runs, no_cache, json_output, verbose, timeout
+        ))
+    else:
+        _run_locally(op, shape, dtype, hardware, num_warmup, num_runs, no_cache, json_output, verbose, timeout)
+
+
+def _run_locally(
+    op: str,
+    shape: list[str],
+    dtype: str,
+    hardware: str | None,
+    num_warmup: int,
+    num_runs: int,
+    no_cache: bool,
+    json_output: bool,
+    verbose: bool,
+    timeout: int,
+) -> None:
+    """Run baseline trace on local GPU."""
+    import torch
+
+    # Check CUDA availability
+    if not torch.cuda.is_available():
+        typer.echo("Error: CUDA not available on this machine", err=True)
+        typer.echo("Use --target or --workspace to run on a remote GPU.", err=True)
+        raise typer.Exit(1)
+
+    # Auto-detect hardware if not specified
+    if hardware is None:
+        hardware = _detect_local_hardware()
+        if hardware:
+            if not json_output:
+                typer.echo(f"Auto-detected hardware: {hardware}")
+        else:
+            gpu_name = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "unknown"
+            if not json_output:
+                typer.echo(f"Warning: No roofline specs for '{gpu_name}'", err=True)
+                typer.echo(f"Supported hardware: {', '.join(HARDWARE_SPECS.keys())}", err=True)
+                typer.echo("Roofline analysis will be skipped.", err=True)
+                typer.echo("")
+
+    # Parse operation
+    try:
+        op_spec = parse_op_string(op)
+    except ValueError as e:
+        typer.echo(f"Error parsing operation: {e}", err=True)
+        raise typer.Exit(1)
+
+    # Parse shapes
+    shapes: dict[str, tuple[int, ...]] = {}
+    for shape_str in shape:
+        try:
+            name, dims = _parse_shape(shape_str)
+            shapes[name] = dims
+        except typer.BadParameter as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1)
+
+    # Update op_spec with shapes and dtype
+    if shapes:
+        op_spec = update_shapes(op_spec, shapes)
+    op_spec = update_dtypes(op_spec, dtype)
+
+    # Validate hardware
+    hw_spec = get_hardware_spec(hardware)
+    if hw_spec is None:
+        typer.echo(f"Warning: Unknown hardware '{hardware}', roofline analysis will be skipped", err=True)
+        typer.echo(f"Supported hardware: {', '.join(HARDWARE_SPECS.keys())}", err=True)
+
+    # Get current environment for cache lookup
+    pytorch_version = torch.__version__
+    props = torch.cuda.get_device_properties(0)
+    
+    # Detect runtime version and architecture (CUDA vs ROCm)
+    if hasattr(torch.version, 'hip') and torch.version.hip:
+        runtime_version = torch.version.hip
+        gpu_arch = getattr(props, 'gcnArchName', f"gfx{props.major}{props.minor}")
+    else:
+        runtime_version = torch.version.cuda or "unknown"
+        gpu_arch = f"sm_{props.major}{props.minor}"
+
+    # Check cache first (unless --no-cache)
+    from_cache = False
+    if not no_cache:
+        cached = lookup_baseline(op_spec, hardware, pytorch_version, runtime_version, gpu_arch)
+        if cached is not None:
+            from_cache = True
+            # Re-compute roofline with current hardware specs (in case they've been updated)
+            config = KernelTraceConfig(op_spec=op_spec, hardware=hardware, num_warmup=0, num_runs=0)
+            from wafer_core.tools.dispatch_baseline.executor import _add_roofline_analysis
+            result = _add_roofline_analysis(cached, config)
+            if not json_output:
+                typer.echo(f"Using cached result (key: {pytorch_version}/{runtime_version}/{gpu_arch})")
+                typer.echo("")
+
+    if not from_cache:
+        # Create config
+        config = KernelTraceConfig(
+            op_spec=op_spec,
+            hardware=hardware,
+            num_warmup=num_warmup,
+            num_runs=num_runs,
+            timeout_seconds=timeout,
+        )
+
+        # Run trace
+        if not json_output:
+            typer.echo(f"Profiling: {op_spec}")
+            typer.echo(f"Hardware: {hardware}")
+            typer.echo("")
+
+        exec_result = trace_kernel_local(config)
+        result = exec_result.result
+
+        # Cache the result
+        if not result.error:
+            store_baseline(
+                result,
+                exec_result.pytorch_version,
+                exec_result.runtime_version,
+                exec_result.gpu_arch,
+            )
+
+    # Output results
+    _output_result(result, json_output, verbose, from_cache)
+
+
+def _detect_local_hardware() -> str:
+    """Detect GPU hardware name from local CUDA device.
+    
+    Only returns hardware names that we have specs for (B200, MI300X).
+    Returns None for unsupported hardware.
+    """
+    import torch
+
+    if not torch.cuda.is_available():
+        return None
+
+    gpu_name = torch.cuda.get_device_name(0).upper()
+
+    # Only return hardware we have roofline specs for
+    if "B200" in gpu_name:
+        return "B200"
+    elif "MI300X" in gpu_name:
+        return "MI300X"
+    else:
+        return None  # Unsupported hardware
+
+
+def _detect_hardware_from_target(target_config) -> str | None:
+    """Detect hardware from target configuration.
+    
+    Only returns hardware names that we have specs for (B200, MI300X).
+    """
+    gpu_type = getattr(target_config, "gpu_type", None)
+    if gpu_type:
+        gpu_upper = gpu_type.upper()
+        if gpu_upper in HARDWARE_SPECS:
+            return gpu_upper
+    return None
+
+
+async def _run_on_target(
+    op: str,
+    shape: list[str],
+    dtype: str,
+    hardware: str | None,
+    target_name: str,
+    num_warmup: int,
+    num_runs: int,
+    no_cache: bool,
+    json_output: bool,
+    verbose: bool,
+    timeout: int,
+) -> None:
+    """Run baseline trace on a configured target via SSH."""
+    from wafer_core.ssh import SSHClient
+    from wafer_core.tools.dispatch_baseline.codegen import generate_trace_script
+    from wafer_core.tools.dispatch_baseline.executor import trace_kernel_remote
+
+    from .targets import load_target
+    from .targets_ops import TargetExecError, get_target_ssh_info
+
+    # Load target config
+    try:
+        target_config = load_target(target_name)
+    except FileNotFoundError:
+        typer.echo(f"Error: Target '{target_name}' not found", err=True)
+        typer.echo("Run 'wafer config targets list' to see available targets", err=True)
+        raise typer.Exit(1)
+
+    # Auto-detect hardware from target if not specified
+    if hardware is None:
+        hardware = _detect_hardware_from_target(target_config)
+        if hardware:
+            if not json_output:
+                typer.echo(f"Auto-detected hardware from target: {hardware}")
+        else:
+            if not json_output:
+                typer.echo(f"Warning: No roofline specs for target's GPU", err=True)
+                typer.echo(f"Supported hardware: {', '.join(HARDWARE_SPECS.keys())}", err=True)
+                typer.echo("Roofline analysis will be skipped.", err=True)
+                typer.echo("")
+
+    # Get SSH info
+    try:
+        ssh_info = await get_target_ssh_info(target_config)
+    except TargetExecError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+
+    # Parse operation and create config
+    try:
+        op_spec = parse_op_string(op)
+    except ValueError as e:
+        typer.echo(f"Error parsing operation: {e}", err=True)
+        raise typer.Exit(1)
+
+    shapes: dict[str, tuple[int, ...]] = {}
+    for shape_str in shape:
+        try:
+            name, dims = _parse_shape(shape_str)
+            shapes[name] = dims
+        except typer.BadParameter as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1)
+
+    if shapes:
+        op_spec = update_shapes(op_spec, shapes)
+    op_spec = update_dtypes(op_spec, dtype)
+
+    config = KernelTraceConfig(
+        op_spec=op_spec,
+        hardware=hardware,
+        num_warmup=num_warmup,
+        num_runs=num_runs,
+    )
+
+    if not json_output:
+        typer.echo(f"Profiling: {op_spec}")
+        typer.echo(f"Target: {target_name}")
+        typer.echo(f"Hardware: {hardware}")
+        typer.echo("")
+
+    # Create SSH client and run trace
+    ssh_client = SSHClient(
+        host=ssh_info.host,
+        port=ssh_info.port,
+        username=ssh_info.user,
+        key_path=str(ssh_info.key_path),
+    )
+
+    try:
+        ssh_client.connect()
+        exec_result = trace_kernel_remote(config, ssh_client)
+        result = exec_result.result
+
+        # Cache the result
+        if not result.error and not no_cache:
+            store_baseline(
+                result,
+                exec_result.pytorch_version,
+                exec_result.runtime_version,
+                exec_result.gpu_arch,
+            )
+    finally:
+        ssh_client.close()
+
+    _output_result(result, json_output, verbose, from_cache=False)
+
+
+async def _run_on_workspace(
+    op: str,
+    shape: list[str],
+    dtype: str,
+    hardware: str | None,
+    workspace_name: str,
+    num_warmup: int,
+    num_runs: int,
+    no_cache: bool,
+    json_output: bool,
+    verbose: bool,
+    timeout: int,
+) -> None:
+    """Run baseline trace on a workspace."""
+    import subprocess
+    import tempfile
+    from pathlib import Path
+
+    from wafer_core.tools.dispatch_baseline.analyzer import parse_trace_output
+    from wafer_core.tools.dispatch_baseline.codegen import generate_trace_script
+    from wafer_core.tools.dispatch_baseline.executor import _add_roofline_analysis
+
+    # Parse operation and create config
+    try:
+        op_spec = parse_op_string(op)
+    except ValueError as e:
+        typer.echo(f"Error parsing operation: {e}", err=True)
+        raise typer.Exit(1)
+
+    shapes: dict[str, tuple[int, ...]] = {}
+    for shape_str in shape:
+        try:
+            name, dims = _parse_shape(shape_str)
+            shapes[name] = dims
+        except typer.BadParameter as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1)
+
+    if shapes:
+        op_spec = update_shapes(op_spec, shapes)
+    op_spec = update_dtypes(op_spec, dtype)
+
+    # Default hardware for workspaces (can be overridden)
+    if hardware is None:
+        # Try to detect from workspace name (only supported hardware)
+        ws_lower = workspace_name.lower()
+        if "b200" in ws_lower:
+            hardware = "B200"
+        elif "mi300" in ws_lower:
+            hardware = "MI300X"
+        else:
+            hardware = None
+        
+        if hardware:
+            if not json_output:
+                typer.echo(f"Auto-detected hardware from workspace name: {hardware}")
+        else:
+            if not json_output:
+                typer.echo(f"Warning: Could not detect hardware from workspace name '{workspace_name}'", err=True)
+                typer.echo(f"Supported hardware: {', '.join(HARDWARE_SPECS.keys())}", err=True)
+                typer.echo("Roofline analysis will be skipped.", err=True)
+                typer.echo("")
+
+    config = KernelTraceConfig(
+        op_spec=op_spec,
+        hardware=hardware,
+        num_warmup=num_warmup,
+        num_runs=num_runs,
+    )
+
+    if not json_output:
+        typer.echo(f"Profiling: {op_spec}")
+        typer.echo(f"Workspace: {workspace_name}")
+        typer.echo(f"Hardware: {hardware}")
+        typer.echo("")
+
+    # Generate script
+    script = generate_trace_script(config)
+
+    # Write to temp file and sync to workspace
+    with tempfile.TemporaryDirectory() as tmpdir:
+        script_path = Path(tmpdir) / "baseline_trace.py"
+        script_path.write_text(script)
+
+        # Sync to workspace using wafer CLI
+        sync_result = subprocess.run(
+            ["wafer", "workspaces", "sync", workspace_name, str(tmpdir)],
+            capture_output=True,
+            text=True,
+        )
+        if sync_result.returncode != 0:
+            typer.echo(f"Error syncing to workspace: {sync_result.stderr}", err=True)
+            raise typer.Exit(1)
+
+        # Execute on workspace
+        exec_result = subprocess.run(
+            ["wafer", "workspaces", "exec", "--timeout", str(timeout), workspace_name,
+             "python /workspace/baseline_trace.py"],
+            capture_output=True,
+            text=True,
+        )
+
+        output = exec_result.stdout + exec_result.stderr
+
+        # Parse result
+        parsed = parse_trace_output(output, op_spec, hardware)
+        result = _add_roofline_analysis(parsed.result, config)
+
+        # Cache the result
+        if not result.error and not no_cache:
+            store_baseline(
+                result,
+                parsed.pytorch_version,
+                parsed.runtime_version,
+                parsed.gpu_arch,
+            )
+
+    _output_result(result, json_output, verbose, from_cache=False)
+
+
+def _output_result(result, json_output: bool, verbose: bool, from_cache: bool = False) -> None:
+    """Output trace result in the requested format."""
+    if json_output:
+        import json
+
+        output = {
+            "op": str(result.op_spec),
+            "hardware": result.hardware,
+            "total_duration_us": result.total_duration_us,
+            "from_cache": from_cache,
+            "kernels": [
+                {
+                    "name": k.name,
+                    "duration_us": k.duration_us,
+                }
+                for k in result.kernels
+            ],
+            "primary_kernel": {
+                "name": result.primary_kernel.name,
+                "duration_us": result.primary_kernel.duration_us,
+            }
+            if result.primary_kernel
+            else None,
+            "roofline": {
+                "achieved_tflops": result.roofline.achieved_tflops,
+                "achieved_memory_bw_tbps": result.roofline.achieved_memory_bw_tbps,
+                "compute_pct_of_peak": result.roofline.compute_pct_of_peak,
+                "memory_bw_pct_of_peak": result.roofline.memory_bw_pct_of_peak,
+                "bottleneck": result.roofline.bottleneck,
+            }
+            if result.roofline
+            else None,
+            "error": result.error,
+        }
+        typer.echo(json.dumps(output, indent=2))
+    else:
+        if result.error:
+            typer.echo(f"Error: {result.error}", err=True)
+            if verbose and result.raw_output:
+                typer.echo("\nRaw output:")
+                typer.echo(result.raw_output)
+            raise typer.Exit(1)
+
+        if from_cache:
+            typer.echo("(from cache)")
+            typer.echo("")
+
+        typer.echo(result.summary())
+
+        if verbose and result.raw_output:
+            typer.echo("\n--- Raw Profiler Output ---")
+            typer.echo(result.raw_output)
+
+
+@baseline_app.command("hardware")
+def hardware_cmd(
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output as JSON",
+    ),
+) -> None:
+    """List supported hardware and their specifications.
+
+    Shows peak FLOPS and memory bandwidth for each supported GPU,
+    used for roofline analysis calculations.
+
+    Examples:
+        wafer baseline hardware
+        wafer baseline hardware --json
+    """
+    if json_output:
+        import json
+
+        output = {
+            name: {
+                "peak_fp16_tflops": spec.peak_fp16_tflops,
+                "peak_fp32_tflops": spec.peak_fp32_tflops,
+                "peak_memory_bw_tbps": spec.peak_memory_bw_tbps,
+                "peak_fp8_tflops": spec.peak_fp8_tflops,
+                "peak_int8_tops": spec.peak_int8_tops,
+            }
+            for name, spec in HARDWARE_SPECS.items()
+        }
+        typer.echo(json.dumps(output, indent=2))
+    else:
+        typer.echo("Supported Hardware for Roofline Analysis")
+        typer.echo("=" * 60)
+        typer.echo("")
+        typer.echo(f"{'Name':<12} {'FP16 TFLOPS':<14} {'FP32 TFLOPS':<14} {'Mem BW (TB/s)':<14}")
+        typer.echo("-" * 60)
+
+        for name, spec in sorted(HARDWARE_SPECS.items()):
+            typer.echo(
+                f"{name:<12} {spec.peak_fp16_tflops:<14.1f} {spec.peak_fp32_tflops:<14.1f} {spec.peak_memory_bw_tbps:<14.2f}"
+            )
+
+        typer.echo("")
+        typer.echo("Note: FP16 TFLOPS shown without sparsity for most GPUs.")
+        typer.echo("Use --json for complete specifications.")
+
+

wafer/cli.py

@@ -8,6 +8,7 @@
 Core commands:
   agent       AI assistant for GPU kernel development
   evaluate    Test kernel correctness and performance
+  baseline    Discover what kernel PyTorch uses for an op
   corpus      Download GPU documentation for local access
   workspaces  Manage cloud GPU environments
 
@@ -279,19 +280,19 @@ from wafer.targets_cli import (
     targets_list as _targets_list_cmd,
 )
 from wafer.targets_cli import (
-    targets_provision as _targets_provision_cmd,
+    targets_pools as _targets_pools_cmd,
 )
 from wafer.targets_cli import (
-    targets_reconcile as _targets_reconcile_cmd,
+    targets_probe as _targets_probe_cmd,
 )
 from wafer.targets_cli import (
-    targets_terminate as _targets_terminate_cmd,
+    targets_provision as _targets_provision_cmd,
 )
 from wafer.targets_cli import (
-    targets_pools as _targets_pools_cmd,
+    targets_reconcile as _targets_reconcile_cmd,
 )
 from wafer.targets_cli import (
-    targets_probe as _targets_probe_cmd,
+    targets_terminate as _targets_terminate_cmd,
 )
 
 # Billing management - nested under config
@@ -323,6 +324,11 @@ gpumode_app = typer.Typer(
 )
 evaluate_app.add_typer(gpumode_app, name="gpumode")
 
+# Baseline discovery (what kernel does PyTorch use?)
+from wafer.baseline import baseline_app
+
+app.add_typer(baseline_app, name="baseline", rich_help_panel="Kernel Development")
+
 # =============================================================================
 # Dev commands (internal, used by web app proxy)
 # =============================================================================
@@ -1592,7 +1598,9 @@ def evaluate(  # noqa: PLR0913
     benchmark: bool = typer.Option(False, "--benchmark", help="Run performance benchmarks"),
     profile: bool = typer.Option(False, "--profile", help="Enable profiling"),
     defensive: bool = typer.Option(
-        False, "--defensive", help="Enable defensive timing to detect evaluation hacking"
+        True,
+        "--defense/--no-defense",
+        help="Run reward hack defense checks after benchmarking. Enabled by default.",
     ),
     sync_artifacts: bool = typer.Option(
         True, "--sync-artifacts/--no-sync-artifacts", help="Download artifacts"
@@ -1606,19 +1614,19 @@ def evaluate(  # noqa: PLR0913
     The evaluation checks:
       1. Correctness: Does the kernel produce the same output as the reference?
       2. Performance (--benchmark): How fast is it compared to the reference?
-      3. Defense (--defensive): Detects evaluation hacking (stream injection, etc.)
+      3. Defense: Detects reward hacking (runs automatically with benchmark, disable with --no-defense)
 
     Examples:
         # Basic correctness check
         wafer evaluate gpumode --impl kernel.py --reference ref.py --test-cases tests.json
 
-        # With benchmarking on a specific target
+        # With benchmarking (defense checks run automatically)
         wafer evaluate gpumode --impl kernel.py --reference ref.py --test-cases tests.json \\
             --target vultr-b200 --benchmark
 
-        # Full evaluation with defensive timing (detects cheating)
+        # Benchmarking without defense checks
         wafer evaluate gpumode --impl kernel.py --reference ref.py --test-cases tests.json \\
-            --benchmark --defensive
+            --benchmark --no-defense
 
     Subcommands:
         gpumode        Use GPUMode format (functional) - RECOMMENDED
@@ -1863,7 +1871,9 @@ def _resolve_pool_query(pool: str, collector) -> tuple[str, object]:
     spec_targets = [t for t in matched_targets if t.spec_name]
     if not spec_targets:
         collector.set_error(
-            "pool", "NoSpecTargets", pool=pool,
+            "pool",
+            "NoSpecTargets",
+            pool=pool,
             message="Matched targets have no spec binding — evaluator needs spec fields",
         )
         collector.finalize()
@@ -1963,7 +1973,9 @@ def kernelbench_evaluate(  # noqa: PLR0913, PLR0915
     ),
     seed: int = typer.Option(42, "--seed", help="Random seed for weight initialization"),
     defensive: bool = typer.Option(
-        False, "--defensive", help="Enable defensive timing to detect evaluation hacking"
+        True,
+        "--defense/--no-defense",
+        help="Run reward hack defense checks after benchmarking. Enabled by default.",
     ),
     backend: str | None = typer.Option(
         None,
@@ -2003,16 +2015,20 @@ def kernelbench_evaluate(  # noqa: PLR0913, PLR0915
     The evaluation checks:
       1. Correctness: Does ModelNew.forward() produce same output as Model.forward()?
       2. Performance (--benchmark): How fast is it compared to the reference?
-      3. Defense (--defensive): Detects evaluation hacking
+      3. Defense: Detects reward hacking (runs automatically with benchmark, disable with --no-defense)
 
     Examples:
         # Basic correctness check
         wafer evaluate kernelbench --impl my_kernel.py --reference problem.py
 
-        # With benchmarking
+        # With benchmarking (defense checks run automatically)
         wafer evaluate kernelbench --impl my_kernel.py --reference problem.py \\
             --target vultr-b200 --benchmark
 
+        # Benchmarking without defense checks
+        wafer evaluate kernelbench --impl my_kernel.py --reference problem.py \\
+            --target vultr-b200 --benchmark --no-defense
+
     Subcommands:
         make-template  Extract a KernelBench problem as template
     """
@@ -2072,12 +2088,15 @@ def kernelbench_evaluate(  # noqa: PLR0913, PLR0915
     if stages == "all":
         resolved_stages = "compile,correctness,benchmark,defense"
 
-    # Handle backward compat: --benchmark and --defensive flags add to stages
+    # Handle --benchmark and --defense/--no-defense flags
     stage_set = set(resolved_stages.split(","))
     if benchmark and "benchmark" not in stage_set:
         stage_set.add("benchmark")
-    if defensive and "defense" not in stage_set:
+    # Defense runs automatically when benchmarking, unless --no-defense
+    if defensive and "benchmark" in stage_set and "defense" not in stage_set:
         stage_set.add("defense")
+    if not defensive:
+        stage_set.discard("defense")
     resolved_stages = ",".join(
         sorted(
             stage_set,
@@ -2411,7 +2430,9 @@ def gpumode_evaluate(  # noqa: PLR0913, PLR0915
     benchmark: bool = typer.Option(False, "--benchmark", help="Run performance benchmarks"),
     profile: bool = typer.Option(False, "--profile", help="Enable profiling"),
     defensive: bool = typer.Option(
-        False, "--defensive", help="Enable defensive timing to detect evaluation hacking"
+        True,
+        "--defense/--no-defense",
+        help="Run reward hack defense checks after benchmarking. Enabled by default.",
     ),
     sync_artifacts: bool = typer.Option(
         True, "--sync-artifacts/--no-sync-artifacts", help="Download artifacts"
@@ -2567,307 +2588,6 @@ def gpumode_evaluate(  # noqa: PLR0913, PLR0915
     else:
         typer.echo(f"Error: {result.error_message}", err=True)
         raise typer.Exit(1)
-
-
-# =============================================================================
-# Push and Remote-Run commands
-# =============================================================================
-
-
-@app.command("push", hidden=True)
-def push(
-    local_path: Path = typer.Argument(..., help="Local directory to upload"),
-    workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace name override"),
-    direct: bool = typer.Option(False, "--direct", "-d", help="Use direct SSH instead of API"),
-    target_name: str | None = typer.Option(
-        None,
-        "--target",
-        "-t",
-        help="Target for --direct mode. See 'wafer config targets list'.",
-        autocompletion=complete_target_name,
-    ),
-) -> None:
-    """Push directory to remote GPU.
-
-    By default, uses wafer-api. Use --direct for direct SSH mode.
-
-    Examples:
-        wafer push ./my_project
-        wafer push . --workspace my-kernel
-        wafer push ./my_project --direct --target vultr-b200
-    """
-    # Validate path
-    if not local_path.exists():
-        typer.echo(f"Error: Path not found: {local_path}", err=True)
-        raise typer.Exit(1)
-
-    if not local_path.is_dir():
-        typer.echo(f"Error: Not a directory: {local_path}", err=True)
-        raise typer.Exit(1)
-
-    # Resolve to absolute path
-    local_path = local_path.resolve()
-
-    if direct:
-        # Direct SSH mode (requires target)
-        if not target_name:
-            typer.echo("Error: --target required for --direct mode", err=True)
-            raise typer.Exit(1)
-
-        from wafer_core.utils.kernel_utils.targets.config import ModalTarget
-
-        from .gpu_run import push_directory as push_direct
-        from .targets import load_target
-
-        try:
-            target = load_target(target_name)
-        except FileNotFoundError:
-            typer.echo(f"Error: Target not found: {target_name}", err=True)
-            typer.echo("List targets with: wafer config targets list", err=True)
-            raise typer.Exit(1) from None
-
-        if isinstance(target, ModalTarget):
-            typer.echo(
-                f"Error: Target '{target_name}' is a Modal target. Direct push requires SSH.",
-                err=True,
-            )
-            raise typer.Exit(1) from None
-
-        typer.echo(f"Connecting to {target.ssh_target}...")
-        try:
-            result = push_direct(local_path, target)
-        except Exception as e:
-            typer.echo(f"Error: {e}", err=True)
-            raise typer.Exit(1) from None
-
-        typer.echo(f"Uploading {len(result.files_uploaded)} files to {result.workspace_path}")
-        for f in result.files_uploaded:
-            typer.echo(f"  ✓ {f}")
-        typer.echo(f"Pushed to: {result.workspace_path}")
-    else:
-        # API mode (default)
-        from .api_client import push_directory as push_api
-
-        workspace_name = workspace or local_path.name
-        typer.echo(f"Pushing {local_path.name} to wafer-api...")
-
-        try:
-            result = push_api(local_path, workspace_name)
-        except Exception as e:
-            typer.echo(f"Error: {e}", err=True)
-            raise typer.Exit(1) from None
-
-        typer.echo(f"Uploaded {len(result.files_uploaded)} files")
-        for f in result.files_uploaded:
-            typer.echo(f"  ✓ {f}")
-        typer.echo(f"Workspace ID: {result.workspace_id}")
-
-
-def _run_direct_mode(
-    cmd_str: str,
-    target_name: str,
-    upload_dir: Path | None,
-    workspace_id: str | None,
-    gpu_id: int | None,
-) -> int:
-    """Run command via direct SSH mode. Returns exit code."""
-    from wafer_core.utils.kernel_utils.targets.config import ModalTarget
-
-    from .gpu_run import push_directory as push_direct
-    from .gpu_run import run_command as run_direct
-    from .targets import load_target
-
-    try:
-        target = load_target(target_name)
-    except FileNotFoundError:
-        typer.echo(f"Error: Target not found: {target_name}", err=True)
-        typer.echo("List targets with: wafer config targets list", err=True)
-        raise typer.Exit(1) from None
-
-    if isinstance(target, ModalTarget):
-        typer.echo(
-            f"Error: Target '{target_name}' is a Modal target. Direct mode requires SSH.", err=True
-        )
-        raise typer.Exit(1) from None
-
-    if not target.docker_image:
-        typer.echo(f"Error: Target '{target_name}' has no docker_image configured", err=True)
-        raise typer.Exit(1)
-
-    # If upload_dir provided, push first
-    workspace_name = workspace_id
-    if upload_dir:
-        typer.echo(f"Uploading {upload_dir.name}...")
-        try:
-            push_result = push_direct(upload_dir, target)
-            workspace_name = push_result.workspace_name
-            typer.echo(f"Uploaded {len(push_result.files_uploaded)} files")
-        except Exception as e:
-            typer.echo(f"Error uploading: {e}", err=True)
-            raise typer.Exit(1) from None
-    elif not workspace_name:
-        workspace_name = "tmp"
-
-    effective_gpu = gpu_id if gpu_id is not None else target.gpu_ids[0]
-    typer.echo(f"Target: {target_name} (docker: {target.docker_image})")
-    typer.echo(f"Workspace: {workspace_name}")
-    typer.echo(f"GPU: {effective_gpu}")
-    typer.echo(f"Command: {cmd_str}")
-    typer.echo("-" * 60)
-
-    try:
-        return run_direct(cmd_str, workspace_name, target, gpu_id)
-    except KeyboardInterrupt:
-        typer.echo("\nInterrupted by user", err=True)
-        raise typer.Exit(130) from None
-    except Exception as e:
-        typer.echo(f"Error: {e}", err=True)
-        raise typer.Exit(1) from None
-
-
-def _run_api_mode(  # noqa: PLR0913
-    cmd_str: str,
-    upload_dir: Path | None,
-    workspace_id: str | None,
-    gpu_id: int | None,
-    gpu_count: int,
-    docker_image: str | None,
-    docker_entrypoint: str | None,
-    pull_image: bool,
-    require_hwc: bool,
-) -> int:
-    """Run command via wafer-api. Returns exit code."""
-    from .api_client import run_command_stream
-
-    if upload_dir:
-        typer.echo(f"Uploading: {upload_dir}")
-    elif workspace_id:
-        typer.echo(f"Workspace: {workspace_id}")
-    if gpu_id is not None:
-        typer.echo(f"GPU: {gpu_id}")
-    if gpu_count > 1:
-        typer.echo(f"GPU count: {gpu_count}")
-    if docker_image:
-        typer.echo(f"Image: {docker_image}")
-    if docker_entrypoint:
-        typer.echo(f"Entrypoint: {docker_entrypoint}")
-    if pull_image:
-        typer.echo("Pull image: yes")
-    typer.echo(f"Command: {cmd_str}")
-    if require_hwc:
-        typer.echo("Hardware counters: required (baremetal)")
-    typer.echo("-" * 60)
-
-    try:
-        return run_command_stream(
-            command=cmd_str,
-            upload_dir=upload_dir,
-            workspace_id=workspace_id,
-            gpu_id=gpu_id,
-            gpu_count=gpu_count,
-            docker_image=docker_image,
-            docker_entrypoint=docker_entrypoint,
-            pull_image=pull_image,
-            require_hardware_counters=require_hwc,
-        )
-    except KeyboardInterrupt:
-        typer.echo("\nInterrupted by user", err=True)
-        raise typer.Exit(130) from None
-    except Exception as e:
-        typer.echo(f"Error: {e}", err=True)
-        raise typer.Exit(1) from None
-
-
-@app.command("remote-run", hidden=True)
-def remote_run(  # noqa: PLR0913
-    command: list[str] = typer.Argument(..., help="Command to run"),
-    upload_dir: Path | None = typer.Option(
-        None, "--upload-dir", "-u", help="Directory to upload (stateless mode)"
-    ),
-    workspace_id: str | None = typer.Option(
-        None, "--workspace-id", "-w", help="Workspace ID (from wafer push)"
-    ),
-    gpu_id: int | None = typer.Option(None, "--gpu", "-g", help="GPU ID"),
-    gpu_count: int = typer.Option(1, "--gpu-count", "-n", help="Number of GPUs (1-8)"),
-    docker_image: str | None = typer.Option(None, "--image", "-i", help="Docker image override"),
-    docker_entrypoint: str | None = typer.Option(
-        None, "--docker-entrypoint", help="Override Docker entrypoint (e.g., 'bash')"
-    ),
-    pull_image: bool = typer.Option(
-        False, "--pull-image", help="Pull image if not available on target"
-    ),
-    require_hwc: bool = typer.Option(
-        False, "--require-hwc", help="Require hardware counters (baremetal)"
-    ),
-    direct: bool = typer.Option(False, "--direct", "-d", help="Use direct SSH instead of API"),
-    target_name: str | None = typer.Option(
-        None,
-        "--target",
-        "-t",
-        help="Target for --direct mode. See 'wafer config targets list'.",
-        autocompletion=complete_target_name,
-    ),
-) -> None:
-    """Run command on remote GPU in Docker.
-
-    Two modes:
-    - High-level (stateless): --upload-dir uploads files and runs command
-    - Low-level: --workspace-id uses existing workspace from 'wafer push'
-
-    By default, uses wafer-api. Use --direct for direct SSH mode.
-
-    Examples:
-        # Stateless: upload and run
-        wafer remote-run --upload-dir ./my_project -- python train.py
-
-        # Run without files
-        wafer remote-run -- nvidia-smi
-
-        # Low-level: use existing workspace
-        wafer remote-run --workspace-id ws_abc123 -- python train.py
-
-        # Direct SSH mode
-        wafer remote-run --upload-dir ./my_project --direct --target vultr-b200 -- python train.py
-    """
-    cmd_str = " ".join(command)
-    if not cmd_str.strip():
-        typer.echo("Error: Empty command", err=True)
-        raise typer.Exit(1)
-
-    if upload_dir and workspace_id:
-        typer.echo("Error: --upload-dir and --workspace-id are mutually exclusive", err=True)
-        raise typer.Exit(1)
-
-    if upload_dir:
-        if not upload_dir.exists():
-            typer.echo(f"Error: Directory not found: {upload_dir}", err=True)
-            raise typer.Exit(1)
-        if not upload_dir.is_dir():
-            typer.echo(f"Error: Not a directory: {upload_dir}", err=True)
-            raise typer.Exit(1)
-        upload_dir = upload_dir.resolve()
-
-    if direct:
-        if not target_name:
-            typer.echo("Error: --target required for --direct mode", err=True)
-            raise typer.Exit(1)
-        exit_code = _run_direct_mode(cmd_str, target_name, upload_dir, workspace_id, gpu_id)
-    else:
-        exit_code = _run_api_mode(
-            cmd_str,
-            upload_dir,
-            workspace_id,
-            gpu_id,
-            gpu_count,
-            docker_image,
-            docker_entrypoint,
-            pull_image,
-            require_hwc,
-        )
-
-    raise typer.Exit(exit_code)
-
-
 # =============================================================================
 # Authentication commands
 # =============================================================================
@@ -6114,7 +5834,7 @@ def ncu_analyze(
     By default, uses local NCU if available, otherwise runs analysis
     remotely via wafer-api (requires authentication: wafer auth login).
 
-    Use --target for direct SSH mode (like wafer remote-run --direct).
+    Use --target for direct SSH mode.
     Use --include-source to fetch SASS assembly with register/instruction data.
 
     Examples:
@@ -7988,7 +7708,7 @@ def compare_fusion_cmd(
         wafer compare fusion amd_trace.json nvidia_trace.json --format csv -o fusion.csv
     """
     from .trace_compare import compare_align
-    
+
     compare_align(
         trace1=trace1,
         trace2=trace2,
@@ -8042,7 +7762,7 @@ def compare_align_cmd(
         wafer compare align amd_trace.json nvidia_trace.json --layer 5
     """
     from .trace_compare import compare_align
-    
+
     compare_align(
         trace1=trace1,
         trace2=trace2,

wafer/evaluate.py

@@ -78,9 +78,10 @@ def _build_docker_run_command(
         for cap in cap_add:
             parts.extend(["--cap-add", cap])
 
-    # GPU access - use single quotes for the device spec to avoid shell escaping issues
+    # GPU access - use --runtime=nvidia alongside --gpus for compatibility
+    # with newer NVIDIA drivers (580+) where --gpus alone may not initialize CUDA
     if gpus:
-        parts.extend(["--gpus", f"'{gpus}'"])
+        parts.extend(["--runtime=nvidia", "--gpus", f"'{gpus}'"])
 
     # Volume mounts
     if volumes:
@@ -3159,15 +3160,35 @@ def main():
             inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs]
 
             if run_defense and defense_module is not None:
-                # Use full defense suite
+                # Use extended defense suite (Makora taxonomy + CUDA-L2)
                 print("[KernelBench] Running defense checks on implementation...")
-                run_all_defenses = defense_module.run_all_defenses
+                run_extended = defense_module.run_all_defenses_extended
                 time_with_defenses = defense_module.time_execution_with_defenses
 
-                # Run defense checks on implementation
-                all_passed, defense_results, _ = run_all_defenses(
+                # Read source code for LLM adversarial evaluator
+                _problem_code = None
+                _kernel_code = None
+                try:
+                    _problem_code = Path(args.reference).read_text()
+                    _kernel_code = Path(args.impl).read_text()
+                except Exception:
+                    pass
+
+                # Input generator for caching/multi-input checks
+                def _input_generator():
+                    _ins = get_inputs()
+                    return tuple(x.cuda() if isinstance(x, torch.Tensor) else x for x in _ins)
+
+                # Run all defense checks (original + extended)
+                all_passed, defense_results, _ = run_extended(
                     lambda *x: new_model(*x),
                     *inputs,
+                    reference_fn=lambda *x: ref_model(*x),
+                    input_generator=_input_generator,
+                    test_shapes=[(128, 128), (256, 256), (512, 512)],
+                    check_precision_ulp=True,
+                    problem_code=_problem_code,
+                    kernel_code=_kernel_code,
                 )
                 results["defense_results"] = {
                     name: {"passed": passed, "message": msg}

wafer/templates/optimize_kernel.py

@@ -35,7 +35,8 @@ Strategy:
 Commands:
 - `wafer evaluate --impl <file> --reference <ref> --test-cases <tests>` - Run evaluation
 - `wafer evaluate --impl <file> --reference <ref> --test-cases <tests> --profile` - With NCU profiling
-- `wafer remote-run "<command>"` - Run arbitrary commands on remote GPU
+- `wafer workspaces exec -- <command>` - Run arbitrary commands on remote GPU
+- `wafer targets exec <target> -- <command>` - Run commands on a configured target via SSH
 
 Output:
 - Summary of optimizations applied
@@ -48,7 +49,8 @@ IMPORTANT: Always verify correctness with wafer evaluate before claiming success
     tools=["read", "write", "edit", "glob", "grep", "bash"],
     bash_allowlist=[
         "wafer evaluate",
-        "wafer remote-run",
+        "wafer workspaces exec",
+        "wafer targets exec",
         "wafer nvidia ncu",
         "wafer nvidia nsys",
         "wafer nvidia perfetto",

{wafer_cli-0.2.30.dist-info → wafer_cli-0.2.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.30
+Version: 0.2.31
 Summary: CLI for running GPU workloads, managing remote workspaces, and evaluating/optimizing kernels
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{wafer_cli-0.2.30.dist-info → wafer_cli-0.2.31.dist-info}/RECORD

@@ -5,12 +5,13 @@ wafer/analytics.py,sha256=qLY6Z16usVHFD8TCv7XBuz7l47vXVdXk-qhOzA-hW_8,8179
 wafer/api_client.py,sha256=i_Az2b2llC3DSW8yOL-BKqa7LSKuxOr8hSN40s-oQXY,6313
 wafer/auth.py,sha256=dwss_se5P-FFc9IN38q4kh_dBrA6k-CguDBkivgcdj0,14003
 wafer/autotuner.py,sha256=41WYP41pTDvMijv2h42vm89bcHtDMJXObDlWmn6xpFU,44416
+wafer/baseline.py,sha256=OrGCAut_xtkH9Ogx4mMU5-94Q0oClIXqac94YRwqERY,21534
 wafer/billing.py,sha256=hEEwtrtIsbPQ3lLJNcyTLMsapUbcuvcVW_e9_0SxzVo,7199
-wafer/cli.py,sha256=zuVZhPdML5AOBtLUqLwAwjl8XMNe9EwQkffZxtBGLx4,282748
+wafer/cli.py,sha256=9wpLZlrKC3_DtkYuNWH42H1x9gJJOkJ32X2bNECG0rY,273013
 wafer/cli_instructions.py,sha256=bziUKDNDAXABVMvKPLEMXm-hFSD2TcFSh-FKRYa949k,4693
 wafer/config.py,sha256=h5Eo9_yfWqWGoPNdVQikI9GoZVUeysunSYiixf1mKcw,3411
 wafer/corpus.py,sha256=CY9T7wXENNDJxnrtI-XsQmXeptrFfKG4x-lngrc9_3s,24748
-wafer/evaluate.py,sha256=QswzCD0CZRT2jpzpeekjNezEPbKHZnvVI7KRQZas8LA,186310
+wafer/evaluate.py,sha256=i15PliAVI3W04_4eju46PBDdh2BwSToLME5n7yGu7dU,187355
 wafer/global_config.py,sha256=iu1HbTDr1695tSeDG2NfkK7PiY7XD6vjCk37w1wHbgk,11920
 wafer/gpu_run.py,sha256=TwqXy72T7f2I7e6n5WWod3xgxCPnDhU0BgLsB4CUoQY,9716
 wafer/inference.py,sha256=tZCO5i05FKY27ewis3CSBHFBeFbXY3xwj0DSjdoMY9s,4314
@@ -36,12 +37,12 @@ wafer/workspaces.py,sha256=J-TXGwHXSZlzRWCew63KNvk6HLJ-zTSELRgzjryTkMk,35710
 wafer/skills/wafer-guide/SKILL.md,sha256=UDsXCD5Kb-lDParKCTf2WkE3kodVs-rja8XeumSBO5U,3934
 wafer/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wafer/templates/ask_docs.py,sha256=15t1Aa4WBMwMox8XmFdzyosOZfBLMdXyaxo3GDb7nTE,2254
-wafer/templates/optimize_kernel.py,sha256=4-MaKm_C9BQHQEllrNLLYkcdhJpcj6D-8zbJ4FdLUEY,2444
+wafer/templates/optimize_kernel.py,sha256=Q4FA_8ECEegW_3DS51mkLCX6Vk1dcWWzY3A_RQ4NW8U,2576
 wafer/templates/optimize_kernelbench.py,sha256=T3co9Y9eSLWDrZG66gwQVFMdnGVoyUQos-TxnMMBLL8,3747
 wafer/templates/trace_analyze.py,sha256=B7CiRlsokERzBjLL-k49kGjpU2zlJZqzTE05xbRS1WI,2878
 wafer/tests/test_eval_cli_parity.py,sha256=SGmaj2NGBZ7GdDF53bXsECvQbV21iHZw8YeL_MJOLk0,7206
-wafer_cli-0.2.30.dist-info/METADATA,sha256=4mvnQyUVD_irJIdhwj0ECm5FEDVXlcmFjklLzZqq1V8,2799
-wafer_cli-0.2.30.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-wafer_cli-0.2.30.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
-wafer_cli-0.2.30.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
-wafer_cli-0.2.30.dist-info/RECORD,,
+wafer_cli-0.2.31.dist-info/METADATA,sha256=rrIOyDKT02oelCRNJTTdlCvidNgVXmNSlE2vXmRsa-U,2799
+wafer_cli-0.2.31.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+wafer_cli-0.2.31.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
+wafer_cli-0.2.31.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
+wafer_cli-0.2.31.dist-info/RECORD,,