fix(runner): allow WorkflowRunner to use an explicit interpreter

The per-claim verifier runs verifier scripts under the interpreter running
Mimosa (sys.executable), where the verifier helper packages were installed.
It did so by overriding runner._python_cmd AFTER constructing WorkflowRunner.
But WorkflowRunner.__init__ validates that a pythonX.Y matching
RuntimeConfig.python_version (default "3.12") exists on PATH and raises
*before* that override runs. On any host without python3.12 on PATH
(e.g. a uv-managed 3.12 that isn't symlinked, with Mimosa itself on 3.13),
evaluation crashed with "Python 3.12 not available" — aborting the whole run
after claim extraction and verifier-spec generation had already completed.

Add RuntimeConfig.python_executable: when set, it short-circuits the
PATH/version resolver (after a --version smoke check), so the construction
check uses the chosen interpreter too. The verifier now passes
python_executable=sys.executable via the config instead of mutating
_python_cmd post-construction. PATH/version resolution is unchanged when
python_executable is unset.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Fosowl

sources/core/evaluators/verifier_per_claim.py

@@ -648,17 +648,21 @@ def _run_verifier(self, uuid: str, claim_id: str, code: str) -> dict[str, Any]:
         """
         scratch = self._runner_temp_root / uuid
         scratch.mkdir(parents=True, exist_ok=True)
+        # Run verifiers under the exact interpreter running Mimosa: that is
+        # where the verifier helper packages were installed, and it avoids
+        # depending on a system pythonX.Y being on PATH. Passing this via the
+        # config (rather than overriding runner._python_cmd after construction)
+        # ensures WorkflowRunner's construction-time availability check uses
+        # this interpreter too, instead of failing when no matching
+        # python_version is found on PATH.
         runner_config = RuntimeConfig(
+            python_executable=sys.executable,
             timeout=self.verifier_timeout,
             temp_dir=scratch,
             requirements_file=None,
             use_pty=False,
         )
         runner = WorkflowRunner(runner_config, execution_dir=str(self.workspace_dir))
-        # Use the Python that's running Mimosa, not the system python3.12 the
-        # runner's resolver picks: that interpreter is where the verifier
-        # helper packages were installed.
-        runner._python_cmd = [sys.executable]
         execution_id = f"verify_{claim_id}"
         thread_timeout = self.verifier_timeout + 10
         result = None

sources/core/workflow_runner.py

@@ -53,7 +53,14 @@ class RuntimeConfig:
     """Configuration controlling how the workflow runner spawns Python.
 
     Attributes:
-        python_version: Target Python version string (e.g. ``"3.12"``).
+        python_version: Target Python version string (e.g. ``"3.12"``). Used
+            to resolve an interpreter from ``PATH`` when ``python_executable``
+            is not set.
+        python_executable: Explicit path to a Python interpreter (e.g.
+            ``sys.executable``). When provided it overrides ``python_version``
+            entirely: the runner uses this exact interpreter and skips the
+            ``PATH``-based version resolution, so it never depends on a
+            matching ``pythonX.Y`` being installed on ``PATH``.
         timeout: Maximum execution time per command, in seconds.
         max_memory_mb: Soft memory cap, in megabytes (advisory).
         max_cpu_percent: Soft CPU cap, as a percentage (advisory).
@@ -68,6 +75,8 @@ class RuntimeConfig:
     """
 
     python_version: str = "3.12"
+    # Explicit interpreter path; when set, overrides python_version resolution.
+    python_executable: str | None = None
     timeout: int = 1800
     max_memory_mb: int = 1024
     max_cpu_percent: int = 100
@@ -120,14 +129,25 @@ def _setup_environment(self) -> None:
         # Convert temp_dir to absolute path to ensure it's created in the right location
         self.config.temp_dir = os.path.abspath(self.config.temp_dir)
         os.makedirs(self.config.temp_dir, exist_ok=True)
-        # Validate python version availability and resolve the executable
+        # Validate python availability and resolve the executable
         if not self._check_python_version():
-            raise RuntimeError(f"Python {self.config.python_version} not available")
+            target = (
+                self.config.python_executable
+                or f"Python {self.config.python_version}"
+            )
+            raise RuntimeError(f"{target} not available")
 
     def _resolve_python_executable(self) -> list[str] | None:
         """
         Find a working Python executable for the configured version.
 
+        When ``config.python_executable`` is set, it short-circuits this
+        resolution: the caller has deliberately chosen an interpreter (e.g.
+        ``sys.executable``, where verifier helper packages were installed), so
+        it is used directly after a ``--version`` smoke check, bypassing the
+        ``PATH``/version search entirely. This is what lets verifiers run on a
+        host that has no ``pythonX.Y`` matching ``python_version`` on ``PATH``.
+
         Versioned candidates are always tried first and accepted as-is because
         they target the exact version by construction:
         - Unix/macOS: ``python3.10`` (versioned binary)
@@ -144,6 +164,21 @@ def _resolve_python_executable(self) -> list[str] | None:
         import subprocess
         import sys
 
+        # An explicit interpreter path overrides version-based PATH resolution.
+        explicit = self.config.python_executable
+        if explicit:
+            try:
+                result = subprocess.run(
+                    [explicit, "--version"],
+                    capture_output=True,
+                    timeout=10,
+                )
+                if result.returncode == 0:
+                    return [explicit]
+            except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+                pass
+            return None
+
         version = self.config.python_version  # e.g. "3.10"
 
         if sys.platform == "win32":