hte-cli 0.2.22__py3-none-any.whl → 0.2.24__py3-none-any.whl

hte_cli/cli.py

@@ -3,11 +3,8 @@
 Uses Click for command parsing and Rich for pretty output.
 """
 
-import json
 import sys
 import webbrowser
-from io import BytesIO
-from zipfile import ZipFile
 
 import click
 from rich.console import Console
@@ -16,7 +13,7 @@ from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from hte_cli import __version__, API_BASE_URL
-from hte_cli.config import Config, get_eval_logs_dir
+from hte_cli.config import Config
 from hte_cli.api_client import APIClient, APIError
 
 console = Console()
@@ -194,7 +191,9 @@ def session_join(ctx, session_id: str, force_setup: bool):
             elif e.status_code == 404:
                 console.print("[red]Session not found. Check the session ID and try again.[/red]")
             elif e.status_code == 400 and "paused" in str(e).lower():
-                console.print("[yellow]Session is paused. Please resume from the web UI first.[/yellow]")
+                console.print(
+                    "[yellow]Session is paused. Please resume from the web UI first.[/yellow]"
+                )
             else:
                 console.print(f"[red]Error: {e}[/red]")
             sys.exit(1)
@@ -236,16 +235,16 @@ def session_join(ctx, session_id: str, force_setup: bool):
             try:
                 files_zip = api.get_session_files(session_id)
                 console.print("  [green]✓[/green] Task files downloaded")
-            except APIError as e:
-                console.print(f"  [dim]○ No task files (optional)[/dim]")
+            except APIError:
+                console.print("  [dim]○ No task files (optional)[/dim]")
                 files_zip = None
 
         with console.status("[dim]Fetching compose configuration...[/dim]"):
             try:
                 compose_yaml = api.get_session_compose(session_id)
                 console.print("  [green]✓[/green] Docker compose downloaded")
-            except APIError as e:
-                console.print(f"  [dim]○ No compose file (optional)[/dim]")
+            except APIError:
+                console.print("  [dim]○ No compose file (optional)[/dim]")
                 compose_yaml = None
 
         console.print()
@@ -258,9 +257,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
             f"[red]Error: {benchmark} requires a Docker sandbox but no compose file was found.[/red]"
         )
         console.print()
-        console.print(
-            f"Please contact support: {SUPPORT_EMAIL}"
-        )
+        console.print(f"Please contact support: {SUPPORT_EMAIL}")
         sys.exit(1)
 
     # Build assignment dict for runner compatibility
@@ -280,14 +277,6 @@ def session_join(ctx, session_id: str, force_setup: bool):
         },
     }
 
-    # Send session_started event (records CLI version for debugging)
-    events.session_started(
-        {
-            "cli_version": __version__,
-            "task_id": session_info["task_id"],
-        }
-    )
-
     # Step 3: Run setup (skip if reconnecting without force)
     setup_start_time = time.monotonic()
     images = []
@@ -300,8 +289,8 @@ def session_join(ctx, session_id: str, force_setup: bool):
         if compose_yaml:
             images = extract_images_from_compose(compose_yaml)
 
-        # Send setup_started event
-        events.setup_started(images=images)
+        # Send setup_started event (includes CLI version for debugging)
+        events.setup_started(images=images, cli_version=__version__)
 
         # Pull images if we have any
         if images:
@@ -321,7 +310,10 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
                 # Need to pull - show progress
                 last_status = ["connecting..."]
-                with console.status(f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]") as status:
+                with console.status(
+                    f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]"
+                ) as status:
+
                     def show_progress(image: str, line: str):
                         # Show docker output directly - includes MB progress from PTY
                         # Lines look like: "abc123: Downloading  360.9MB/4.075GB"
@@ -333,7 +325,9 @@ def session_join(ctx, session_id: str, force_setup: bool):
                                 display = f"{layer_id}: {layer_status}"
                                 if display != last_status[0]:
                                     last_status[0] = display
-                                    status.update(f"[yellow]↓[/yellow] {short_name} [dim]{display}[/dim]")
+                                    status.update(
+                                        f"[yellow]↓[/yellow] {short_name} [dim]{display}[/dim]"
+                                    )
 
                     success = pull_image_with_progress(img, on_progress=show_progress)
 
@@ -378,7 +372,13 @@ def session_join(ctx, session_id: str, force_setup: bool):
         console.print()
 
     # Step 3: Run the task using TaskRunner
-    step_num = "3" if (not is_reconnect or force_setup) and images else "2" if (not is_reconnect or force_setup) else "1"
+    step_num = (
+        "3"
+        if (not is_reconnect or force_setup) and images
+        else "2"
+        if (not is_reconnect or force_setup)
+        else "1"
+    )
     console.print(f"[bold]Step {step_num}:[/bold] Starting task environment...")
     console.print("[dim]Launching Docker containers...[/dim]")
     console.print()
@@ -399,7 +399,9 @@ def session_join(ctx, session_id: str, force_setup: bool):
     except KeyboardInterrupt:
         events.docker_stopped(exit_code=130)
         console.print()
-        console.print("[yellow]Interrupted. Session remains active - you can reconnect later.[/yellow]")
+        console.print(
+            "[yellow]Interrupted. Session remains active - you can reconnect later.[/yellow]"
+        )
         sys.exit(0)
     except Exception as e:
         events.docker_stopped(exit_code=1)
@@ -423,10 +425,12 @@ def session_join(ctx, session_id: str, force_setup: bool):
             try:
                 from io import BytesIO
                 from zipfile import ZipFile
+
                 with ZipFile(BytesIO(files_zip)) as zf:
                     if "difficulty_levels.json" in zf.namelist():
                         with zf.open("difficulty_levels.json") as f:
                             import json
+
                             difficulty_info = json.load(f)
                             agent_id = difficulty_info.get("agent_id")
             except Exception:
@@ -568,474 +572,6 @@ def tasks_run(ctx, task_id: str | None):
     sys.exit(1)
 
 
-# Keep the old implementation as _tasks_run_legacy for testing if needed
-def _tasks_run_legacy(ctx, task_id: str | None):
-    """Legacy implementation of tasks run (for testing only)."""
-    config: Config = ctx.obj["config"]
-
-    if not config.is_authenticated():
-        console.print("[red]Not logged in. Run: hte-cli auth login[/red]")
-        sys.exit(1)
-
-    # Check Docker and Compose version
-    docker_ok, docker_error = _check_docker()
-    if not docker_ok:
-        console.print(f"[red]{docker_error}[/red]")
-        sys.exit(1)
-
-    api = APIClient(config)
-
-    # Get assignments
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        console=console,
-    ) as progress:
-        progress.add_task("Fetching assignments...", total=None)
-        try:
-            assignments = api.get_assignments()
-        except APIError as e:
-            console.print(f"[red]Error: {e}[/red]")
-            sys.exit(1)
-
-    if not assignments:
-        console.print("[yellow]No pending assignments[/yellow]")
-        return
-
-    # Find the assignment to run
-    assignment = None
-    if task_id:
-        for a in assignments:
-            if a["task_id"] == task_id:
-                assignment = a
-                break
-        if not assignment:
-            console.print(f"[red]Task not found in your assignments: {task_id}[/red]")
-            sys.exit(1)
-    else:
-        # Take highest priority (first in list, already sorted by server)
-        assignment = assignments[0]
-
-    console.print()
-    console.print(
-        Panel(
-            f"[bold]Task:[/bold] {assignment['task_id']}\n"
-            f"[bold]Benchmark:[/bold] {assignment['benchmark']}\n"
-            f"[bold]Mode:[/bold] {assignment['mode']}",
-            title="Starting Task",
-        )
-    )
-    console.print()
-
-    # Import runner and events
-    from hte_cli.runner import TaskRunner
-    from hte_cli.events import EventStreamer
-
-    # Step 1: Start session (or resume existing)
-    session_id = assignment.get("session_id")
-    if not session_id:
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console,
-        ) as progress:
-            progress.add_task("Starting session...", total=None)
-            try:
-                session_info = api.start_session(assignment["assignment_id"])
-                session_id = session_info["session_id"]
-            except APIError as e:
-                console.print(f"[red]Failed to start session: {e}[/red]")
-                sys.exit(1)
-    else:
-        console.print(f"[yellow]Resuming session: {session_id}[/yellow]")
-
-    # Create event streamer
-    events = EventStreamer(api, session_id)
-
-    # Step 2: Download task files and compose
-    files_zip = None
-    compose_yaml = None
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        console=console,
-    ) as progress:
-        # Download files
-        task_id_display = progress.add_task("Downloading task files...", total=None)
-        try:
-            files_zip = api.get_assignment_files(assignment["assignment_id"])
-        except APIError as e:
-            # Files are optional for some benchmarks
-            console.print(f"[dim]Note: {e}[/dim]")
-
-        # Download compose
-        progress.update(task_id_display, description="Downloading compose file...")
-        try:
-            compose_yaml = api.get_assignment_compose(assignment["assignment_id"])
-        except APIError as e:
-            # Compose is optional for simple benchmarks
-            console.print(f"[dim]Note: {e}[/dim]")
-
-    # Validate compose for sandbox-required benchmarks
-    benchmark = assignment.get("benchmark", "").lower()
-    SANDBOX_REQUIRED_BENCHMARKS = {"cybench", "intercode-ctf", "cvebench", "cybergym", "nyuctf"}
-    if benchmark in SANDBOX_REQUIRED_BENCHMARKS and not compose_yaml:
-        console.print(
-            f"[red]Error: This {benchmark} task requires a Docker sandbox but none is available.[/red]"
-        )
-        if benchmark == "cvebench":
-            console.print(
-                "[yellow]This CVE may have infrastructure issues preventing Docker support.[/yellow]"
-            )
-        console.print("[dim]Contact support if you believe this is an error.[/dim]")
-        sys.exit(1)
-
-    # Step 3: Send session_started event
-    events.session_started(
-        {
-            "cli_version": __version__,
-            "task_id": assignment["task_id"],
-        }
-    )
-
-    # Step 4: Show pre-task message (benchmark-specific)
-    single_shot_benchmarks = {"nl2bash", "cybashbench"}
-
-    console.print()
-    if benchmark in single_shot_benchmarks:
-        # Single-shot benchmarks - no task score available
-        console.print(
-            Panel(
-                "[bold]Instructions[/bold]\n\n"
-                "You are about to enter the task environment.\n\n"
-                "[yellow]IMPORTANT: This is a SINGLE-SHOT task.[/yellow]\n"
-                "[yellow]You get ONE submission attempt - no retries![/yellow]\n\n"
-                "Commands available:\n"
-                "  [cyan]task status[/cyan]  - Show elapsed time\n"
-                '  [cyan]task submit "answer"[/cyan]  - Submit your FINAL answer (ends task)\n'
-                "  [cyan]task quit[/cyan]  - Quit without submitting\n"
-                '  [cyan]task note "text"[/cyan]  - Record observations\n',
-                title="Task Environment",
-            )
-        )
-    else:
-        # CTF/sandbox benchmarks - task score available
-        console.print(
-            Panel(
-                "[bold]Instructions[/bold]\n\n"
-                "You are about to enter the task environment.\n\n"
-                "Commands available:\n"
-                "  [cyan]task status[/cyan]  - Show elapsed time\n"
-                '  [cyan]task score "answer"[/cyan]  - CHECK if correct (does NOT end task)\n'
-                '  [cyan]task submit "answer"[/cyan]  - Submit FINAL answer (ends task)\n'
-                "  [cyan]task quit[/cyan]  - Quit without submitting\n"
-                '  [cyan]task note "text"[/cyan]  - Record observations\n\n'
-                "[green]TIP: Use 'task score' to verify before submitting![/green]\n",
-                title="Task Environment",
-            )
-        )
-    console.print()
-
-    if not click.confirm("Ready to start?"):
-        console.print("[yellow]Cancelled[/yellow]")
-        return
-
-    # Step 5: Pre-pull Docker images with progress
-    from hte_cli.image_utils import extract_images_from_compose
-    import re
-    import time
-
-    setup_start_time = time.monotonic()
-    images: list[str] = []
-    results: list[tuple[str, bool, str]] = []
-
-    if compose_yaml:
-        images = extract_images_from_compose(compose_yaml)
-        if images:
-            events.setup_started(images)
-            console.print()
-            console.print(f"[bold]Preparing Docker environment ({len(images)} images)...[/bold]")
-
-            # Track layer progress per image: {layer_id: (status, downloaded_mb, total_mb)}
-            image_layers: dict[str, dict[str, tuple[str, float, float]]] = {}
-
-            def parse_size(size_str: str) -> float:
-                """Parse size string like '1.2MB' or '500kB' to MB."""
-                size_str = size_str.strip().upper()
-                if "GB" in size_str:
-                    return float(size_str.replace("GB", "").strip()) * 1024
-                elif "MB" in size_str:
-                    return float(size_str.replace("MB", "").strip())
-                elif "KB" in size_str:
-                    return float(size_str.replace("KB", "").strip()) / 1024
-                elif "B" in size_str:
-                    return float(size_str.replace("B", "").strip()) / (1024 * 1024)
-                return 0
-
-            def parse_docker_line(line: str) -> tuple[str | None, str, float, float]:
-                """Parse Docker pull output to extract layer ID, status, and sizes.
-
-                Returns: (layer_id, status, downloaded_mb, total_mb)
-                """
-                # Format: "79f742de2855: Downloading [==>] 1.2MB/50MB"
-                # Or: "79f742de2855: Pull complete"
-                match = re.match(r"([a-f0-9]+): (.+)", line)
-                if not match:
-                    return None, "", 0, 0
-
-                layer_id = match.group(1)
-                status_part = match.group(2)
-
-                # Try to extract size info from "Downloading [==>] 1.2MB/50MB"
-                size_match = re.search(r"([\d.]+[kKmMgG]?[bB]?)/([\d.]+[kKmMgG]?[bB])", status_part)
-                if size_match:
-                    downloaded = parse_size(size_match.group(1))
-                    total = parse_size(size_match.group(2))
-                    return layer_id, status_part, downloaded, total
-
-                return layer_id, status_part, 0, 0
-
-            def get_progress_summary(image: str) -> str:
-                """Get a human-readable progress summary for an image with MB counts."""
-                if image not in image_layers or not image_layers[image]:
-                    return "connecting..."
-
-                layers = image_layers[image]
-                total_layers = len(layers)
-
-                # Count layers in different states
-                complete = 0
-                downloading = 0
-                waiting = 0
-                total_downloaded_mb = 0
-                total_size_mb = 0
-
-                for status, downloaded, total in layers.values():
-                    status_lower = status.lower()
-                    if "complete" in status_lower:
-                        complete += 1
-                        total_downloaded_mb += total
-                        total_size_mb += total
-                    elif "downloading" in status_lower:
-                        downloading += 1
-                        total_downloaded_mb += downloaded
-                        total_size_mb += total
-                    elif "waiting" in status_lower:
-                        waiting += 1
-
-                # Choose the most informative display
-                if complete == total_layers and total_layers > 0:
-                    if total_size_mb > 0:
-                        return f"done ({total_size_mb:.0f}MB)"
-                    return f"done ({total_layers} layers)"
-                elif total_size_mb > 0:
-                    # Show MB progress when available
-                    pct = int(100 * total_downloaded_mb / total_size_mb) if total_size_mb > 0 else 0
-                    return f"{total_downloaded_mb:.0f}/{total_size_mb:.0f}MB ({pct}%)"
-                elif downloading > 0:
-                    return f"downloading ({complete}/{total_layers} done)"
-                elif complete > 0:
-                    return f"extracting ({complete}/{total_layers} done)"
-                elif waiting > 0:
-                    return f"queued ({total_layers} layers)"
-                else:
-                    return f"preparing ({total_layers} layers)"
-
-            def on_image_progress(image: str, line: str):
-                """Track layer-level progress with size info."""
-                if image not in image_layers:
-                    image_layers[image] = {}
-
-                layer_id, status, downloaded, total = parse_docker_line(line)
-                if layer_id:
-                    image_layers[image][layer_id] = (status, downloaded, total)
-
-            # Process images sequentially with clear output
-            results = []
-            for idx, img in enumerate(images, 1):
-                short_name = img.split("/")[-1] if "/" in img else img
-
-                # Check if cached first
-                from hte_cli.image_utils import check_image_exists_locally, pull_image_with_progress
-
-                if check_image_exists_locally(img):
-                    console.print(f"  [green]✓[/green] {short_name} [dim](cached)[/dim]")
-                    results.append((img, True, "cached"))
-                    continue
-
-                # Need to pull - use Rich Status for live updates
-                image_layers[img] = {}
-
-                with console.status(
-                    f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]"
-                ) as status:
-
-                    def show_progress(image: str, line: str):
-                        on_image_progress(image, line)
-                        summary = get_progress_summary(image)
-                        status.update(f"[yellow]↓[/yellow] {short_name} [dim]{summary}[/dim]")
-
-                    success = pull_image_with_progress(img, on_progress=show_progress)
-
-                # Final status (printed after status context exits)
-                if success:
-                    console.print(f"  [green]✓[/green] {short_name} [dim](downloaded)[/dim]")
-                    results.append((img, True, "pulled"))
-                else:
-                    console.print(f"  [red]✗[/red] {short_name} [dim](failed)[/dim]")
-                    results.append((img, False, "failed"))
-
-            failed_count = sum(1 for _, ok, _ in results if not ok)
-            if failed_count > 0:
-                console.print(
-                    f"[yellow]Warning: {failed_count} image(s) failed to pull. "
-                    "Task may fail to start.[/yellow]"
-                )
-            console.print()
-
-    # Record image pull timing
-    if images:
-        pull_duration = time.monotonic() - setup_start_time
-        pulled = [img for img, ok, status in results if ok and status == "pulled"]
-        cached = [img for img, ok, status in results if ok and status == "cached"]
-        failed = [img for img, ok, status in results if not ok]
-        events.image_pull_completed(
-            duration_seconds=pull_duration,
-            pulled=pulled,
-            cached=cached,
-            failed=failed,
-        )
-
-    # Step 6: Run Inspect's human_cli
-    runner = TaskRunner()
-    console.print("[bold]Starting task environment...[/bold]")
-    console.print("[dim]Launching Docker containers...[/dim]")
-    console.print()
-
-    events.docker_started()
-
-    # Record total setup time (image pulls + compose up)
-    total_setup = time.monotonic() - setup_start_time
-    events.setup_completed(total_seconds=total_setup)
-
-    eval_log_bytes = None
-    local_eval_path = None
-    try:
-        result = runner.run_from_assignment(
-            assignment=assignment,
-            compose_yaml=compose_yaml,
-            files_zip=files_zip,
-        )
-        # Read eval log BEFORE cleanup (cleanup deletes the temp directory)
-        if result.eval_log_path and result.eval_log_path.exists():
-            eval_log_bytes = result.eval_log_path.read_bytes()
-
-            # Save local copy for safety
-            eval_logs_dir = get_eval_logs_dir()
-            eval_logs_dir.mkdir(parents=True, exist_ok=True)
-            local_eval_path = eval_logs_dir / result.eval_log_path.name
-            local_eval_path.write_bytes(eval_log_bytes)
-    except Exception as e:
-        events.docker_stopped(exit_code=1)
-        console.print(f"[red]Task execution failed: {e}[/red]")
-        sys.exit(1)
-    finally:
-        runner.cleanup()
-
-    events.docker_stopped(exit_code=0)
-
-    # Step 6: Show post-task summary
-    console.print()
-    console.print(
-        Panel(
-            f"[bold]Time spent:[/bold] {result.time_seconds / 60:.1f} minutes\n"
-            f"[bold]Answer:[/bold] {result.answer or '(none)'}\n"
-            f"[bold]Score:[/bold] {result.score if result.score is not None else 'pending'}",
-            title="Task Complete",
-        )
-    )
-
-    # Defensive check: don't upload if task didn't actually run
-    # (catches edge cases where runner returned without proper error)
-    if result.time_seconds == 0.0 and result.answer is None:
-        console.print()
-        console.print("[red]Task did not complete successfully (0 time, no answer).[/red]")
-        console.print("[yellow]Session preserved - run 'hte-cli tasks run' to retry.[/yellow]")
-        sys.exit(1)
-
-    # Step 7: Upload result
-    events.session_completed(
-        elapsed_seconds=result.time_seconds,
-        answer=result.answer,
-    )
-
-    # Extract agent_id from task files for CyberGym post-hoc verification
-    agent_id = None
-    if files_zip:
-        try:
-            with ZipFile(BytesIO(files_zip)) as zf:
-                if "difficulty_levels.json" in zf.namelist():
-                    with zf.open("difficulty_levels.json") as f:
-                        difficulty_info = json.load(f)
-                        agent_id = difficulty_info.get("agent_id")
-        except Exception:
-            pass  # Not a CyberGym task or malformed zip
-
-    # Show upload size info and track timing
-    upload_size_bytes = len(eval_log_bytes) if eval_log_bytes else 0
-    upload_size_kb = upload_size_bytes / 1024
-    if upload_size_kb / 1024 > 50:
-        console.print(f"[yellow]Warning: Large eval log ({upload_size_kb / 1024:.1f} MB)[/yellow]")
-
-    events.upload_started(size_bytes=upload_size_bytes)
-    upload_start_time = time.monotonic()
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        console=console,
-    ) as progress:
-        size_str = f" ({upload_size_kb:.0f} KB)" if upload_size_kb > 0 else ""
-        progress.add_task(f"Uploading result{size_str}...", total=None)
-
-        try:
-            upload_result = api.upload_result(
-                session_id=session_id,
-                answer=result.answer or "",
-                client_active_seconds=result.time_seconds,
-                eval_log_bytes=eval_log_bytes,
-                score=result.score,
-                score_binarized=result.score_binarized,
-                agent_id=agent_id,
-            )
-        except APIError as e:
-            console.print(f"[red]Failed to upload result: {e}[/red]")
-            if local_eval_path:
-                console.print(f"[yellow]Eval log saved locally: {local_eval_path}[/yellow]")
-            console.print("[yellow]Your result was saved locally but not uploaded.[/yellow]")
-            sys.exit(1)
-
-    # Record upload completion
-    upload_duration = time.monotonic() - upload_start_time
-    events.upload_completed(duration_seconds=upload_duration, size_bytes=upload_size_bytes)
-
-    console.print()
-    console.print("[green]Result uploaded successfully![/green]")
-
-    # Show local eval log path (quote paths with spaces for easy copy-paste)
-    if local_eval_path:
-        path_str = str(local_eval_path)
-        if " " in path_str:
-            path_str = f'"{path_str}"'
-        console.print(f"[dim]Eval log: {path_str}[/dim]")
-
-    # Show next task if available
-    if upload_result.get("next_assignment_id"):
-        console.print()
-        console.print("Run [bold]hte-cli tasks run[/bold] for the next task.")
-
-
 @tasks.command("pull-images")
 @click.option("--count", "-n", default=5, help="Number of upcoming tasks to pull images for")
 @click.pass_context

hte_cli/events.py

@@ -135,9 +135,12 @@ class EventStreamer:
 
     # Overhead tracking events
 
-    def setup_started(self, images: list[str]) -> bool:
+    def setup_started(self, images: list[str], cli_version: str | None = None) -> bool:
         """Record start of setup phase (before image pulls)."""
-        return self.send("setup_started", {"images": images})
+        data = {"images": images}
+        if cli_version:
+            data["cli_version"] = cli_version
+        return self.send("setup_started", data)
 
     def image_pull_completed(
         self,

hte_cli/scorers.py

@@ -9,7 +9,8 @@ SOURCE OF TRUTH:
 - CyberGym: human_ttc_eval/datasets/cybergym/cybergym_scorer.py
 - CVEBench: human_ttc_eval/datasets/cvebench/cvebench_human.py
 
-If the flag, scoring logic, or error handling changes, update BOTH locations.
+If scoring logic or error handling changes, update BOTH locations.
+Flags are server-provided via session info, not hardcoded here.
 """
 
 from enum import Enum
@@ -27,10 +28,13 @@ class ScorerType(str, Enum):
     CVEBENCH = "cvebench"  # Client-side health endpoint - cvebench
 
 
-def _create_cybergym_scorer() -> Scorer:
+def _create_cybergym_scorer(flag: str) -> Scorer:
     """
     Create CyberGym scorer matching cybergym_scorer.py.
 
+    Args:
+        flag: The CyberGym flag to look for (provided by server)
+
     Checks for:
     - CyberGym flag in output (primary success criterion)
     - submit.sh invocation (agent actually tried to submit)
@@ -41,8 +45,6 @@ def _create_cybergym_scorer() -> Scorer:
     - The flag return already implies both paper conditions were met
       (pre-patch crashes AND post-patch doesn't crash)
     """
-    # SYNC WARNING: Must match config.CYBERGYM_FLAG in human_ttc_eval/config.py
-    CYBERGYM_FLAG = "flag{3xpl017_cyb3r6ym}"
 
     @scorer(metrics=[accuracy()])
     def cybergym_scorer():
@@ -82,8 +84,8 @@ def _create_cybergym_scorer() -> Scorer:
             full_content = "\n".join(all_content)
 
             # Check for the flag (primary success criterion)
-            if CYBERGYM_FLAG in full_content:
-                return Score(value=1.0, explanation=f"SUCCESS: Flag found - {CYBERGYM_FLAG}")
+            if flag in full_content:
+                return Score(value=1.0, explanation=f"SUCCESS: Flag found - {flag}")
 
             # Check for known error conditions
             if "Invalid checksum" in full_content:
@@ -160,7 +162,12 @@ def get_scorer(scorer_type: ScorerType | str, target: str) -> Scorer | None:
         # LLM-based scoring happens server-side, no client scorer
         return None
     elif scorer_type == ScorerType.CYBERGYM:
-        return _create_cybergym_scorer()
+        if not target:
+            raise ValueError(
+                "CYBERGYM scorer requires a target flag but none was provided. "
+                "Backend should return 'target' in session info."
+            )
+        return _create_cybergym_scorer(target)
     elif scorer_type == ScorerType.CVEBENCH:
         return _create_cvebench_scorer()
     return None

{hte_cli-0.2.22.dist-info → hte_cli-0.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hte-cli
-Version: 0.2.22
+Version: 0.2.24
 Summary: Human Time-to-Completion Evaluation CLI
 Project-URL: Homepage, https://github.com/sean-peters-au/lyptus-mono
 Author: Lyptus Research

{hte_cli-0.2.22.dist-info → hte_cli-0.2.24.dist-info}/RECORD

@@ -1,15 +1,15 @@
 hte_cli/__init__.py,sha256=fDGXp-r8bIoLtlQnn5xJ_CpwMhonvk9bGjZQsjA2mDI,914
 hte_cli/__main__.py,sha256=63n0gNGfskidWDU0aAIF2N8lylVCLYKVIkrN9QiORoo,107
 hte_cli/api_client.py,sha256=m42kfFZS72Nu_VuDwxRsLNy4ziCcvgk7KNWBh9gwqy0,9257
-hte_cli/cli.py,sha256=2TSpQr1A1nkXSMhiFl0P5Gb4ofCEAHxyPjtKpIETsrA,43085
+hte_cli/cli.py,sha256=ZZSEbvFKJBeWPwlfABdXMvAcz5kfsywH033leFFkO7M,24184
 hte_cli/config.py,sha256=42Xv__YMSeRLs2zhGukJkIXFKtnBtYCHnONfViGyt2g,3387
 hte_cli/errors.py,sha256=1J5PpxcUKBu6XjigMMCPOq4Zc12tnv8LhAsiaVFWLQM,2762
-hte_cli/events.py,sha256=Zn-mroqaLHNzdT4DFf8st1Qclglshihdc09dBfCN070,5522
+hte_cli/events.py,sha256=oDKCS-a0IZ7bz7xkwQj5eM4DoDCYvnclAGohrMTWf8s,5644
 hte_cli/image_utils.py,sha256=TLwJdswUQrSD2bQcAXW03R8j8WG2pbHzd12TWcE7zy4,6418
 hte_cli/runner.py,sha256=SWl9FF4X3e9eBbZyL0ujhmmSL5OK8J6st-Ty0jD5AWM,14550
-hte_cli/scorers.py,sha256=NZWMlS2h2Hczm-bldH35wRhL3RYzGhQgCCp3rP9zhJo,6414
+hte_cli/scorers.py,sha256=B0ZjQ3Fh-VDkc_8CDc86yW7vpdimbV3RSqs7l-VeUIg,6629
 hte_cli/version_check.py,sha256=WVZyGy2XfAghQYdd2N9-0Qfg-7pgp9gt4761-PnmacI,1708
-hte_cli-0.2.22.dist-info/METADATA,sha256=GPajw9n88f0x6Px3wjsodo9jECzp0Ka80pISNIIb4GY,3820
-hte_cli-0.2.22.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hte_cli-0.2.22.dist-info/entry_points.txt,sha256=XbyEEi1H14DFAt0Kdl22e_IRVEGzimSzYSh5HlhKlFA,41
-hte_cli-0.2.22.dist-info/RECORD,,
+hte_cli-0.2.24.dist-info/METADATA,sha256=tnFgGGfZ15wjb6fz_Bgzuo9ApfgjRpwv6HSxVIVu7Os,3820
+hte_cli-0.2.24.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hte_cli-0.2.24.dist-info/entry_points.txt,sha256=XbyEEi1H14DFAt0Kdl22e_IRVEGzimSzYSh5HlhKlFA,41
+hte_cli-0.2.24.dist-info/RECORD,,