hte-cli 0.2.24__tar.gz → 0.2.25__tar.gz

{hte_cli-0.2.24 → hte_cli-0.2.25}/.gitignore

@@ -1,4 +1,5 @@
 .env
+.envrc
 .DS_Store
 
 docs/build/

{hte_cli-0.2.24 → hte_cli-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hte-cli
-Version: 0.2.24
+Version: 0.2.25
 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.24 → hte_cli-0.2.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hte-cli"
-version = "0.2.24"
+version = "0.2.25"
 description = "Human Time-to-Completion Evaluation CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{hte_cli-0.2.24 → hte_cli-0.2.25}/src/hte_cli/cli.py

@@ -172,6 +172,17 @@ def session_join(ctx, session_id: str, force_setup: bool):
         console.print("[red]Not logged in. Run: hte-cli auth login[/red]")
         sys.exit(1)
 
+    # Check Docker is running before we start (with retry prompt)
+    while True:
+        docker_ok, docker_error = _check_docker()
+        if docker_ok:
+            break
+        console.print(f"[red]{docker_error}[/red]")
+        console.print()
+        if not click.confirm("Start Docker and retry?", default=True):
+            sys.exit(1)
+        console.print("[dim]Checking Docker again...[/dim]")
+
     api = APIClient(config)
 
     # Step 1: Join session
@@ -201,8 +212,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
     # Check if reconnecting (session already in_progress)
     is_reconnect = session_info.get("status") == "in_progress"
 
-    if is_reconnect and not force_setup:
-        console.print("[yellow]Reconnecting to existing session...[/yellow]")
+    # Always run setup on reconnect - previous attempt may have failed
+    # (e.g., image pull failed, Docker wasn't running, etc.)
+    if is_reconnect:
+        force_setup = True
+        console.print("[yellow]Reconnecting to existing session (re-running setup)...[/yellow]")
         console.print()
 
     console.print(
@@ -219,7 +233,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
     import time
     from hte_cli.events import EventStreamer
     from hte_cli.runner import TaskRunner
-    from hte_cli.image_utils import extract_images_from_compose, pull_image_with_progress
+    from hte_cli.image_utils import (
+        extract_images_from_compose,
+        extract_image_platforms_from_compose,
+        pull_image_with_progress,
+    )
 
     # Create event streamer
     events = EventStreamer(api, session_id)
@@ -285,9 +303,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
     failed_images = []
 
     if not is_reconnect or force_setup:
-        # Extract images from compose
+        # Extract images and their platforms from compose
+        image_platforms = {}
         if compose_yaml:
             images = extract_images_from_compose(compose_yaml)
+            image_platforms = extract_image_platforms_from_compose(compose_yaml)
 
         # Send setup_started event (includes CLI version for debugging)
         events.setup_started(images=images, cli_version=__version__)
@@ -298,9 +318,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
             console.print(f"[bold]Step 2:[/bold] Pulling {len(images)} Docker image(s)...")
             pull_start = time.monotonic()
+            pull_errors = {}
 
             for img in images:
                 short_name = img.split("/")[-1][:40]
+                platform = image_platforms.get(img)
 
                 # Check if already cached
                 if check_image_exists_locally(img):
@@ -310,6 +332,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
                 # Need to pull - show progress
                 last_status = ["connecting..."]
+                last_error = [""]
                 with console.status(
                     f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]"
                 ) as status:
@@ -328,14 +351,23 @@ def session_join(ctx, session_id: str, force_setup: bool):
                                     status.update(
                                         f"[yellow]↓[/yellow] {short_name} [dim]{display}[/dim]"
                                     )
+                        # Capture error messages
+                        if "error" in line.lower() or "denied" in line.lower():
+                            last_error[0] = line
 
-                    success = pull_image_with_progress(img, on_progress=show_progress)
+                    success = pull_image_with_progress(
+                        img, platform=platform, on_progress=show_progress
+                    )
 
                 if success:
                     console.print(f"  [green]✓[/green] {short_name} [dim](downloaded)[/dim]")
                     pulled_images.append(img)
                 else:
-                    console.print(f"  [red]✗[/red] {short_name} [dim](failed)[/dim]")
+                    platform_note = f" (platform: {platform})" if platform else ""
+                    console.print(f"  [red]✗[/red] {short_name}{platform_note} [dim](failed)[/dim]")
+                    if last_error[0]:
+                        console.print(f"      [dim]{last_error[0][:60]}[/dim]")
+                        pull_errors[img] = last_error[0]
                     failed_images.append(img)
 
             pull_duration = time.monotonic() - pull_start
@@ -347,6 +379,20 @@ def session_join(ctx, session_id: str, force_setup: bool):
             )
             console.print()
 
+            # Fail fast if any required image couldn't be pulled
+            if failed_images:
+                console.print(
+                    f"[red]Error: Failed to pull {len(failed_images)} required Docker image(s).[/red]"
+                )
+                console.print()
+                console.print("[yellow]Troubleshooting:[/yellow]")
+                console.print("  1. Check Docker is running: docker info")
+                console.print("  2. Try manual pull: docker pull python:3.12-slim --platform linux/amd64")
+                console.print("  3. Check network connectivity")
+                console.print()
+                console.print("Session remains active - you can retry with: hte-cli session join " + session_id)
+                sys.exit(1)
+
         # Send setup_completed - THIS STARTS THE TIMER ON SERVER
         total_setup = time.monotonic() - setup_start_time
         events.setup_completed(total_seconds=total_setup)
@@ -644,7 +690,7 @@ def _check_docker() -> tuple[bool, str | None]:
             timeout=10,
         )
         if result.returncode != 0:
-            return False, "Docker is not running. Start Docker Desktop or the Docker daemon."
+            return False, "Docker is not running. Start Docker (Docker Desktop, colima, or dockerd)."
     except FileNotFoundError:
         return False, "Docker is not installed. Install from https://docs.docker.com/get-docker/"
     except Exception as e:

{hte_cli-0.2.24 → hte_cli-0.2.25}/src/hte_cli/image_utils.py

@@ -38,6 +38,33 @@ def extract_images_from_compose(compose_yaml: str) -> list[str]:
         return []
 
 
+def extract_image_platforms_from_compose(compose_yaml: str) -> dict[str, str | None]:
+    """
+    Extract Docker image names and their platforms from a compose.yaml string.
+
+    Args:
+        compose_yaml: Docker Compose YAML content
+
+    Returns:
+        Dict mapping image names to their platform (or None if no platform specified)
+    """
+    try:
+        compose_data = yaml.safe_load(compose_yaml)
+        if not compose_data or "services" not in compose_data:
+            return {}
+
+        image_platforms = {}
+        for service_name, service_config in compose_data.get("services", {}).items():
+            if isinstance(service_config, dict) and "image" in service_config:
+                image = service_config["image"]
+                platform = service_config.get("platform")
+                image_platforms[image] = platform
+        return image_platforms
+    except yaml.YAMLError as e:
+        logger.warning(f"Failed to parse compose.yaml: {e}")
+        return {}
+
+
 def check_image_exists_locally(image: str) -> bool:
     """
     Check if a Docker image exists locally.
@@ -61,16 +88,20 @@ def check_image_exists_locally(image: str) -> bool:
 
 def pull_image_with_progress(
     image: str,
+    platform: str | None = None,
     on_progress: Callable[[str, str], None] | None = None,
     on_complete: Callable[[str, bool], None] | None = None,
+    on_error: Callable[[str, str], None] | None = None,
 ) -> bool:
     """
     Pull a Docker image with progress callbacks using PTY for real progress output.
 
     Args:
         image: Image name to pull
+        platform: Optional platform to pull (e.g., "linux/amd64")
         on_progress: Callback(image, status_line) called for each progress update
         on_complete: Callback(image, success) called when pull completes
+        on_error: Callback(image, error_message) called when pull fails
 
     Returns:
         True if pull succeeded, False otherwise
@@ -79,8 +110,12 @@ def pull_image_with_progress(
         # Use PTY to get real progress output from docker
         master_fd, slave_fd = pty.openpty()
 
+        cmd = ["docker", "pull", image]
+        if platform:
+            cmd.extend(["--platform", platform])
+
         process = subprocess.Popen(
-            ["docker", "pull", image],
+            cmd,
             stdout=slave_fd,
             stderr=slave_fd,
             stdin=slave_fd,

{hte_cli-0.2.24 → hte_cli-0.2.25}/tests/e2e/automated_runner.py

@@ -169,7 +169,7 @@ ENVIRONMENT_CHECKS = {
         ("cat /etc/os-release | grep '^NAME='", "Kali", "Kali Linux base image"),
         # CyberGym-specific: submit.sh in home dir for PoC submission
         ("test -f /root/submit.sh && echo 'submit.sh'", "submit.sh", "submit.sh present in /root"),
-        ("test -x /root/submit.sh && echo 'executable'", "executable", "submit.sh is executable"),
+        # Note: submit.sh executable check removed - file is made executable by task command
         # Required tools - STRICT (same image as cybench)
         ("which gdb", "/usr/bin/gdb", "gdb at /usr/bin/gdb"),
         ("which ghidra", "/usr/bin/ghidra", "ghidra at /usr/bin/ghidra"),
@@ -369,6 +369,63 @@ def create_session_for_task(task_id: str) -> str | None:
         return None
 
 
+def test_join_endpoint(session_id: str, benchmark: str) -> list[TestResult]:
+    """Test the session join endpoint while session is in 'created' state.
+
+    This tests the API response before the CLI actually joins.
+    """
+    import json
+    from pathlib import Path
+
+    results = []
+    base_url = os.environ.get("HTE_API_URL", "https://cyber-task-horizons.com")
+
+    config_path = Path.home() / "Library" / "Application Support" / "hte-cli" / "config.json"
+    if not config_path.exists():
+        results.append(TestResult("Join API test", False, "", "No CLI config"))
+        return results
+
+    config = json.loads(config_path.read_text())
+    headers = {"Authorization": f"Bearer {config['api_key']}"}
+
+    # Test the join endpoint
+    response = requests.post(
+        f"{base_url}/api/v1/cli/sessions/{session_id}/join",
+        headers=headers,
+        timeout=30,
+    )
+
+    if response.status_code != 200:
+        results.append(TestResult("Join API response", False, "", f"Status {response.status_code}"))
+        return results
+
+    data = response.json()
+
+    # Test: scorer_type is present
+    if "scorer_type" in data:
+        results.append(TestResult("Join returns scorer_type", True, data["scorer_type"]))
+    else:
+        results.append(TestResult("Join returns scorer_type", False, "", "Missing scorer_type"))
+
+    # Test: intermediate_scoring is present
+    if "intermediate_scoring" in data:
+        results.append(
+            TestResult("Join returns intermediate_scoring", True, str(data["intermediate_scoring"]))
+        )
+    else:
+        results.append(TestResult("Join returns intermediate_scoring", False, "", "Missing"))
+
+    # Test: target is present for flag-based benchmarks
+    if benchmark in ("cybench", "nyuctf", "intercode-ctf"):
+        has_target = "target" in data or ("task" in data and "target" in data.get("task", {}))
+        if has_target:
+            results.append(TestResult("Join returns target", True, "Present"))
+        else:
+            results.append(TestResult("Join returns target", False, "", "Missing target"))
+
+    return results
+
+
 def run_automated_test(task_id: str, benchmark: str, timeout: int = 300) -> list[TestResult]:
     """
     Run automated E2E test for a task using pexpect.
@@ -389,6 +446,11 @@ def run_automated_test(task_id: str, benchmark: str, timeout: int = 300) -> list
         return results
     results.append(TestResult("Session creation", True, f"Session: {session_id[:8]}..."))
 
+    # Test join endpoint while session is in 'created' state (before CLI joins)
+    console.print("Testing join endpoint...")
+    join_results = test_join_endpoint(session_id, benchmark)
+    results.extend(join_results)
+
     # Start the CLI using the new session join flow
     # Session has status="created", so CLI will run full setup
     # Use explicit pipx path to test the published PyPI version, not local dev
@@ -634,24 +696,45 @@ def run_automated_test(task_id: str, benchmark: str, timeout: int = 300) -> list
             except Exception:
                 pass
             docker_child.sendline(sub_tests["score_cmd"])
-            time.sleep(2)
-            docker_child.expect(prompt_patterns[:-1], timeout=30)
-            output = strip_ansi(docker_child.before or "")
 
             expected_score = sub_tests.get("score_expect")
             if expected_score:
-                passed = expected_score.lower() in output.lower()
-                details = (
-                    output[:200]
-                    if passed
-                    else f"Expected '{expected_score}' in output: {output[:100]}..."
-                )
+                # Wait specifically for the score output, not just any prompt
+                # The score output appears as "Answer: ..., Score: I" or similar
+                try:
+                    idx = docker_child.expect(
+                        [expected_score, pexpect.TIMEOUT],
+                        timeout=10,
+                    )
+                    if idx == 0:
+                        # Found expected output - capture surrounding context
+                        output = strip_ansi(docker_child.before or "") + expected_score
+                        # Read a bit more to get the full score line
+                        try:
+                            extra = docker_child.read_nonblocking(size=100, timeout=1)
+                            output += strip_ansi(extra)
+                        except Exception:
+                            pass
+                        passed = True
+                        details = output[:200]
+                    else:
+                        # Timeout - capture what we have
+                        output = strip_ansi(docker_child.before or "")
+                        passed = False
+                        details = f"Timeout waiting for '{expected_score}': {output[:100]}..."
+                except Exception as e:
+                    passed = False
+                    details = f"Error: {e}"
                 results.append(TestResult("task score", passed, details))
             else:
+                # No expected output - just check command runs
+                time.sleep(2)
+                docker_child.expect(prompt_patterns[:-1], timeout=30)
+                output = strip_ansi(docker_child.before or "")
                 results.append(
                     TestResult(
                         "task score",
-                        True,  # Just checking it runs
+                        True,
                         output[:200],
                     )
                 )

{hte_cli-0.2.24 → hte_cli-0.2.25}/tests/e2e/conftest.py

@@ -102,14 +102,56 @@ def cleanup_stale_sessions_globally():
     This runs once at the start of the entire pytest session.
     The constraint is one active session per USER, so any leftover
     sessions from previous runs will block new session creation.
+
+    Also ensures we have sessions in various states for testing:
+    - At least one 'cancelled' session (for test_join_cancelled_session_fails)
+    - At least one 'paused' session (for test_join_paused_session_fails)
     """
     try:
         user_id = get_test_user_id()
+
+        # First, clean up truly stale sessions
         ssh_query(f"""
             UPDATE sessions SET status = 'abandoned'
             WHERE user_id = '{user_id}'
-            AND status IN ('created', 'in_progress', 'paused')
+            AND status IN ('created', 'in_progress')
+        """)
+
+        # Ensure we have at least one cancelled session for testing
+        # (convert an abandoned session if none exist)
+        cancelled_count = ssh_query(f"""
+            SELECT COUNT(*) FROM sessions
+            WHERE user_id = '{user_id}' AND status = 'cancelled'
+        """)
+        if int(cancelled_count or 0) == 0:
+            ssh_query(f"""
+                UPDATE sessions SET status = 'cancelled'
+                WHERE user_id = '{user_id}'
+                AND status = 'abandoned'
+                AND id = (
+                    SELECT id FROM sessions
+                    WHERE user_id = '{user_id}' AND status = 'abandoned'
+                    LIMIT 1
+                )
+            """)
+
+        # Ensure we have at least one paused session for testing
+        paused_count = ssh_query(f"""
+            SELECT COUNT(*) FROM sessions
+            WHERE user_id = '{user_id}' AND status = 'paused'
         """)
+        if int(paused_count or 0) == 0:
+            ssh_query(f"""
+                UPDATE sessions SET status = 'paused'
+                WHERE user_id = '{user_id}'
+                AND status = 'abandoned'
+                AND id = (
+                    SELECT id FROM sessions
+                    WHERE user_id = '{user_id}' AND status = 'abandoned'
+                    LIMIT 1
+                )
+            """)
+
     except RuntimeError:
         # Test user doesn't exist yet - setup hasn't run
         pass

{hte_cli-0.2.24 → hte_cli-0.2.25}/tests/e2e/e2e_test.py

@@ -158,6 +158,112 @@ def ssh_command(cmd: str) -> str:
     return result.stdout.strip()
 
 
+def _create_test_session_states():
+    """Create sessions in cancelled and paused states for edge-case tests.
+
+    This enables TestSessionJoin tests that verify joining cancelled/paused
+    sessions fails appropriately.
+
+    Uses the proper API flow:
+    1. Login as test user (JWT auth for web UI routes)
+    2. Create sessions via CLI API
+    3. Cancel/pause them via web UI API
+    """
+    # Get CLI API key for creating sessions
+    if not CLI_CONFIG_PATH.exists():
+        console.print("[yellow]CLI config not found, skipping state creation[/yellow]")
+        return
+
+    config = json.loads(CLI_CONFIG_PATH.read_text())
+    cli_headers = {"Authorization": f"Bearer {config['api_key']}"}
+
+    # Login as test user to get JWT for web UI routes
+    login_response = requests.post(
+        f"{BASE_URL}/api/v1/auth/login",
+        json={"email": TEST_EMAIL, "password": TEST_PASSWORD},
+        timeout=30,
+    )
+    if login_response.status_code != 200:
+        console.print("[yellow]Could not login test user, skipping state creation[/yellow]")
+        return
+
+    jwt_token = login_response.json()["access_token"]
+    jwt_headers = {"Authorization": f"Bearer {jwt_token}"}
+
+    # Find two pending assignments
+    user_id = ssh_query(f"SELECT id FROM users WHERE email = '{TEST_EMAIL}'")
+    assignments = ssh_query(f"""
+        SELECT a.id FROM assignments a
+        LEFT JOIN sessions s ON s.assignment_id = a.id
+            AND s.status IN ('created', 'in_progress', 'paused', 'cancelled')
+        WHERE a.user_id = '{user_id}'
+        AND a.status = 'pending'
+        AND s.id IS NULL
+        LIMIT 2
+    """)
+
+    if not assignments:
+        console.print("[yellow]No available assignments for state tests[/yellow]")
+        return
+
+    assignment_ids = [a for a in assignments.split("\n") if a]
+
+    # Create and cancel a session
+    if len(assignment_ids) >= 1:
+        # Create session via CLI API
+        create_resp = requests.post(
+            f"{BASE_URL}/api/v1/cli/assignments/{assignment_ids[0]}/create-session",
+            headers=cli_headers,
+            timeout=30,
+        )
+        if create_resp.status_code == 200:
+            session_id = create_resp.json()["session_id"]
+            # Cancel via web UI API
+            cancel_resp = requests.post(
+                f"{BASE_URL}/api/v1/sessions/{session_id}/cancel",
+                headers=jwt_headers,
+                json={"reason": "testing", "notes": "E2E test cancelled session"},
+                timeout=30,
+            )
+            if cancel_resp.status_code == 200:
+                console.print(f"[dim]Created cancelled session: {session_id[:8]}...[/dim]")
+            else:
+                console.print(
+                    f"[yellow]Failed to cancel session: {cancel_resp.status_code}[/yellow]"
+                )
+
+    # Create and pause a session
+    if len(assignment_ids) >= 2:
+        # Create session via CLI API
+        create_resp = requests.post(
+            f"{BASE_URL}/api/v1/cli/assignments/{assignment_ids[1]}/create-session",
+            headers=cli_headers,
+            timeout=30,
+        )
+        if create_resp.status_code == 200:
+            session_id = create_resp.json()["session_id"]
+            # Join to make it in_progress (required before pause)
+            join_resp = requests.post(
+                f"{BASE_URL}/api/v1/cli/sessions/{session_id}/join",
+                headers=cli_headers,
+                timeout=30,
+            )
+            if join_resp.status_code == 200:
+                # Pause via web UI API
+                pause_resp = requests.patch(
+                    f"{BASE_URL}/api/v1/sessions/{session_id}/pause",
+                    headers=jwt_headers,
+                    json={"reason": "testing", "notes": "E2E test paused session"},
+                    timeout=30,
+                )
+                if pause_resp.status_code == 200:
+                    console.print(f"[dim]Created paused session: {session_id[:8]}...[/dim]")
+                else:
+                    console.print(
+                        f"[yellow]Failed to pause session: {pause_resp.status_code}[/yellow]"
+                    )
+
+
 @click.group()
 def cli():
     """E2E Test Suite for cyber-task-horizons."""
@@ -765,6 +871,7 @@ def full(admin_password: str, yes: bool, skip_setup: bool, cleanup_after: bool):
 
     from automated_runner import run_benchmark_test
 
+    first_benchmark_done = False
     for benchmark in BENCHMARK_TASKS.keys():
         console.print(f"\n[bold]--- {benchmark} ---[/bold]")
         try:
@@ -779,10 +886,34 @@ def full(admin_password: str, yes: bool, skip_setup: bool, cleanup_after: bool):
             console.print(f"[red]{benchmark}: ERROR - {e}[/red]")
             results["phase2"][benchmark] = False
 
+        # Phase 2.5: After first benchmark, run session-join tests while sessions still exist
+        if not first_benchmark_done:
+            first_benchmark_done = True
+            console.print("\n[dim]Running session-join tests (while sessions active)...[/dim]")
+            join_result = subprocess.run(
+                [
+                    "uv",
+                    "run",
+                    "pytest",
+                    str(tests_dir / "test_session_lifecycle.py::TestSessionJoin"),
+                    "-v",
+                    "--tb=short",
+                ],
+                cwd=tests_dir.parent.parent,
+            )
+            if join_result.returncode != 0:
+                console.print(
+                    "[yellow]Session join tests had issues (some skips expected)[/yellow]"
+                )
+
     phase2_passed = all(results["phase2"].values())
     if not phase2_passed:
         console.print("\n[yellow]Phase 2 had failures - continuing to Phase 3[/yellow]")
 
+    # Phase 2.9: Create cancelled and paused sessions for edge-case tests
+    console.print("\n[dim]Creating test sessions in cancelled/paused states...[/dim]")
+    _create_test_session_states()
+
     # Phase 3: Session verification tests
     console.print("\n" + "=" * 60)
     console.print("[bold cyan]PHASE 3: Session Verification Tests[/bold cyan]")

{hte_cli-0.2.24 → hte_cli-0.2.25}/tests/e2e/test_eval_logs.py

@@ -339,7 +339,35 @@ class TestEvalLogIntegrity:
                 ), f"Session ID not in path: {session_id} -> {path}"
 
     def test_no_orphaned_eval_logs(self):
-        """All eval logs on VPS should have corresponding sessions."""
+        """All eval logs on VPS should have corresponding sessions.
+
+        We ignore orphans that are:
+        1. From E2E test tasks (setup deletes sessions but not files)
+        2. From before the current DB started (historical artifacts from dev testing)
+
+        Only orphans from non-E2E tasks after the DB was created are flagged.
+        """
+        import re
+
+        from tests.e2e.conftest import EXPECTED_TASKS
+
+        # Build set of E2E task path patterns (slashes become underscores in paths)
+        e2e_task_patterns = set()
+        for benchmark, tasks in EXPECTED_TASKS.items():
+            for task in tasks:
+                # Path format: /benchmark/task_id_sanitized/
+                sanitized = task.replace("/", "_")
+                e2e_task_patterns.add(f"/{benchmark}/{sanitized}/")
+
+        # Get the earliest session date to filter out pre-DB orphans
+        earliest_session = ssh_query("SELECT MIN(created_at) FROM sessions")
+        # Extract YYYYMMDD from earliest session (format: 2026-01-08 04:19:22)
+        earliest_date = None
+        if earliest_session:
+            date_match = re.match(r"(\d{4})-(\d{2})-(\d{2})", earliest_session)
+            if date_match:
+                earliest_date = date_match.group(1) + date_match.group(2) + date_match.group(3)
+
         # Get all eval log paths from DB
         db_paths = ssh_query("""
             SELECT eval_log_path FROM sessions
@@ -352,9 +380,43 @@ class TestEvalLogIntegrity:
         disk_set = set(disk_files.split("\n")) if disk_files else set()
 
         # Check for orphans (files on disk not in DB)
-        orphans = disk_set - db_set - {""}
+        all_orphans = disk_set - db_set - {""}
+
+        # Separate orphans by category
+        e2e_orphans = set()
+        pre_db_orphans = set()
+        real_orphans = set()
+
+        # Pattern to extract date from filename: {uuid}_{YYYYMMDD}_{HHMMSS}.eval.gz
+        date_pattern = re.compile(r"_(\d{8})_\d{6}\.eval\.gz$")
+
+        for orphan in all_orphans:
+            # Check if from E2E test task
+            is_e2e = any(pattern in orphan for pattern in e2e_task_patterns)
+            if is_e2e:
+                e2e_orphans.add(orphan)
+                continue
+
+            # Check if from before the DB started
+            if earliest_date:
+                date_match = date_pattern.search(orphan)
+                if date_match and date_match.group(1) < earliest_date:
+                    pre_db_orphans.add(orphan)
+                    continue
+
+            # This is a real orphan - could be lost expert data
+            real_orphans.add(orphan)
+
+        # Log expected orphans
+        if e2e_orphans:
+            print(f"Note: {len(e2e_orphans)} orphaned eval logs from E2E test tasks (expected)")
+        if pre_db_orphans:
+            print(
+                f"Note: {len(pre_db_orphans)} orphaned eval logs from before DB started (historical)"
+            )
 
-        # Some orphans might be acceptable (old tests, etc.)
-        # Just report, don't fail
-        if orphans:
-            pytest.skip(f"Found {len(orphans)} potentially orphaned eval logs")
+        # Real orphans are a problem - these could be lost expert data
+        assert len(real_orphans) == 0, (
+            f"Found {len(real_orphans)} orphaned eval logs from non-E2E tasks after DB started "
+            f"(files on disk without DB records). First 5: {list(real_orphans)[:5]}"
+        )

{hte_cli-0.2.24 → hte_cli-0.2.25}/tests/e2e/test_session_lifecycle.py

@@ -80,7 +80,16 @@ class TestSessionCreation:
             SELECT DISTINCT status FROM sessions
             WHERE user_id = '{get_test_user_id()}'
         """)
-        valid_statuses = {"created", "pending", "in_progress", "submitted", "abandoned", "skipped"}
+        valid_statuses = {
+            "created",
+            "pending",
+            "in_progress",
+            "submitted",
+            "abandoned",
+            "skipped",
+            "cancelled",
+            "paused",
+        }
         for status in statuses.split("\n"):
             if status:
                 assert status in valid_statuses, f"Invalid status: {status}"

{hte_cli-0.2.24 → hte_cli-0.2.25}/uv.lock

@@ -625,7 +625,7 @@ wheels = [
 
 [[package]]
 name = "hte-cli"
-version = "0.2.23"
+version = "0.2.24"
 source = { editable = "." }
 dependencies = [
     { name = "click" },