lean-runtime 2.0.5__tar.gz → 2.0.7__tar.gz

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 2.0.7
+
+- Retry an OCI layer once from a clean partial after size or SHA-256 integrity
+  verification fails, bypassing intermediary caches while preserving strict
+  digest validation and emitting structured retry diagnostics.
+
+## 2.0.6
+
+- Preserve the highest-ranked Lean compiler rejection when automatic discovery
+  exhausts its candidates, including raw output and parsed diagnostics in both
+  human and JSON `lean-run` output.
+- Add line-oriented and NDJSON request/response helpers to `InteractiveSession`
+  for incremental REPLs and ready-to-run checker programs.
+
 ## 2.0.5
 
 - Integrate bounded exact-environment discovery into the `lean-runtime` package.

{lean_runtime-2.0.5/lean_runtime.egg-info → lean_runtime-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.5
+Version: 2.0.7
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/docs/python-api.md

@@ -179,9 +179,7 @@ with environment.spawn_interactive(
     policy=ExecutionPolicy(timeout_seconds=3600, memory_mb=4096),
 ) as session:
     request = {"id": 1, "method": "get_info", "params": {}}
-    session.stdin.write(json.dumps(request) + "\n")
-    session.stdin.flush()
-    response = json.loads(session.stdout.readline())
+    response = session.request_json(request)
     assert session.running
 
 result = session.close()
@@ -199,6 +197,12 @@ the original text is still returned to the caller. Callers of tools that emit
 substantial data on both streams should drain both streams to avoid ordinary
 subprocess pipe backpressure.
 
+For line-oriented tools, `send_line()` and `read_line()` provide incremental
+REPL-style access. `request_line()` serializes one request/response exchange,
+and `request_json()` does the same for NDJSON protocols. The request helpers
+are locked so concurrent callers cannot interleave protocol frames. The raw
+`stdin`, `stdout`, and `stderr` pipes remain available for other protocols.
+
 ## Progress events
 
 ```python

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/docs/ready-programs.md

@@ -20,11 +20,14 @@ program = runtime.create_program(
 )
 
 with program.spawn_interactive() as session:
-    session.stdin.write("hello\n")
-    session.stdin.flush()
-    print(session.stdout.readline())
+    print(session.request_line("hello"))
 ```
 
+For an NDJSON checker, `session.request_json({...})` keeps the compiled process
+alive and returns one decoded response per request. This is the fast path for
+large batches: prepare and verify the checker once, then stream compact inputs
+instead of elaborating a new Lean source file for every item.
+
 `create_program` records the program's files and computer compatibility. Opening
 it later with `runtime.program(program.id)` verifies that neither has changed.
 

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/lean_runtime/discovery/engine.py

@@ -336,11 +336,17 @@ def discover(
             DISCOVERY_EXHAUSTED,
             f"Lean did not accept the source in any of {len(attempts)} tested candidates",
         )
+    rejection_diagnostics = tuple(
+        diagnostic
+        for attempt in attempts
+        if attempt.status == "lean_rejected"
+        for diagnostic in attempt.diagnostics
+    )
     return DiscoveryResult(
         status="not_found",
         confidence="exhausted",
         plan=plan,
         attempts=tuple(attempts),
         duration_seconds=time.monotonic() - started,
-        diagnostics=(reason,),
+        diagnostics=(reason, *rejection_diagnostics),
     )

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/lean_runtime/discovery/result.py

@@ -124,9 +124,22 @@ class DiscoveryResult:
         compiled = next((item for item in self.attempts if item.status == "compiled"), None)
         return compiled.environment_id if compiled is not None else None
 
+    @property
+    def rejection_attempt(self) -> CandidateAttempt | None:
+        """Return the highest-ranked attempt for which Lean rejected the source."""
+        return next(
+            (
+                attempt
+                for attempt in self.attempts
+                if attempt.status == "lean_rejected" and attempt.execution_result is not None
+            ),
+            None,
+        )
+
     def raise_for_error(self) -> DiscoveryResult:
         if self.status != "found":
-            detail = self.diagnostics[0].detail if self.diagnostics else self.status
+            details = [item.detail for item in self.diagnostics]
+            detail = ": ".join(dict.fromkeys(details)) if details else self.status
             raise DiscoveryError(f"Lean environment discovery did not succeed: {detail}")
         return self
 

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/lean_runtime/environments.py

@@ -17,7 +17,7 @@ from contextlib import suppress
 from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
-from typing import Any, Generic, TextIO, TypeVar, cast
+from typing import Any, Generic, Literal, TextIO, TypeVar, cast
 
 from ._git import git_command
 from ._paths import remove_tree
@@ -291,6 +291,7 @@ class InteractiveSession:
         self._cleanup = cleanup
         self._result: ExecutionResult | None = None
         self._closing = threading.Lock()
+        self._io = threading.RLock()
 
     @property
     def stdin(self) -> TextIO:
@@ -316,6 +317,63 @@ class InteractiveSession:
         """Return the process exit code, or ``None`` while it is running."""
         return self._process.poll()
 
+    def _reader(self, stream: Literal["stdout", "stderr"]) -> InteractiveTextReader:
+        if stream == "stdout":
+            return self.stdout
+        if stream == "stderr":
+            return self.stderr
+        raise ValueError("stream must be 'stdout' or 'stderr'")
+
+    def send_line(self, line: str) -> None:
+        """Send and flush one line-oriented protocol request."""
+        if not isinstance(line, str):
+            raise TypeError("interactive request must be a string")
+        if "\n" in line or "\r" in line:
+            raise ValueError("interactive request must contain exactly one line")
+        with self._io:
+            if not self.running:
+                raise EnvironmentError("interactive process is not running")
+            try:
+                self.stdin.write(line + "\n")
+                self.stdin.flush()
+            except (BrokenPipeError, OSError, ValueError) as exc:
+                raise EnvironmentError("interactive process did not accept the request") from exc
+
+    def read_line(self, *, stream: Literal["stdout", "stderr"] = "stdout") -> str:
+        """Read one response line from stdout or stderr."""
+        with self._io:
+            response = self._reader(stream).readline()
+            if response == "":
+                raise EnvironmentError(
+                    f"interactive process ended before producing a {stream} response"
+                )
+            return response.removesuffix("\n").removesuffix("\r")
+
+    def request_line(
+        self,
+        line: str,
+        *,
+        response_stream: Literal["stdout", "stderr"] = "stdout",
+    ) -> str:
+        """Atomically send one line and read its corresponding response."""
+        with self._io:
+            self.send_line(line)
+            return self.read_line(stream=response_stream)
+
+    def request_json(
+        self,
+        value: object,
+        *,
+        response_stream: Literal["stdout", "stderr"] = "stdout",
+    ) -> Any:
+        """Round-trip one newline-delimited JSON value through the live process."""
+        request = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+        response = self.request_line(request, response_stream=response_stream)
+        try:
+            return json.loads(response)
+        except json.JSONDecodeError as exc:
+            raise EnvironmentError("interactive process returned invalid JSON") from exc
+
     def close(self) -> ExecutionResult:
         """Send EOF, stop if necessary, persist provenance, and remove the instance."""
         with self._closing:

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/lean_runtime/oci.py

@@ -32,6 +32,7 @@ _BEARER_PARAMETER = re.compile(r'([a-zA-Z]+)="([^"]*)"')
 _DIGEST = re.compile(r"sha256:([0-9a-f]{64})")
 _ACCEPT = ", ".join((INDEX_MEDIA_TYPE, MANIFEST_MEDIA_TYPE))
 DEFAULT_ENVIRONMENT_LIBRARIES = ("oci://ghcr.io/alerad/lean-runtime-cache",)
+_BLOB_INTEGRITY_ATTEMPTS = 2
 
 
 class SignatureVerifier(Protocol):
@@ -215,52 +216,73 @@ class OCIRegistryClient:
                     return destination
                 destination.unlink()
             temporary = destination.with_name(f".{destination.name}.partial")
-            if temporary.exists() and temporary.stat().st_size > size:
-                temporary.unlink()
-            offset = temporary.stat().st_size if temporary.exists() else 0
-            request = urllib.request.Request(self._url(f"blobs/{digest}"))
-            if offset:
-                request.add_header("Range", f"bytes={offset}-")
-            events.emit(
-                "library.layer_download_started",
-                "Downloading OCI blob",
-                digest=digest,
-                size=size,
-            )
-            observed = hashlib.sha256()
-            written = offset
-            if offset:
-                with temporary.open("rb") as existing:
-                    for chunk in iter(lambda: existing.read(1024 * 1024), b""):
-                        observed.update(chunk)
-            try:
-                response = self._request(request)
-                if offset and response.status != 206:
-                    offset = 0
-                    written = 0
-                    observed = hashlib.sha256()
+            for attempt in range(1, _BLOB_INTEGRITY_ATTEMPTS + 1):
+                if temporary.exists() and temporary.stat().st_size > size:
+                    temporary.unlink()
+                offset = temporary.stat().st_size if temporary.exists() else 0
+                request = urllib.request.Request(self._url(f"blobs/{digest}"))
+                if offset:
+                    request.add_header("Range", f"bytes={offset}-")
+                if attempt > 1:
+                    request.add_header("Cache-Control", "no-cache")
+                events.emit(
+                    "library.layer_download_started",
+                    "Downloading OCI blob",
+                    digest=digest,
+                    size=size,
+                    attempt=attempt,
+                    resumed_bytes=offset,
+                )
+                observed = hashlib.sha256()
+                written = offset
                 if offset:
-                    content_range = response.headers.get("Content-Range", "")
-                    if not content_range.startswith(f"bytes {offset}-"):
-                        response.close()
-                        temporary.unlink(missing_ok=True)
-                        raise EnvironmentError("OCI registry returned an invalid byte range")
-                mode = "ab" if offset else "wb"
-                with response, temporary.open(mode) as output:
-                    while chunk := response.read(1024 * 1024):
-                        written += len(chunk)
-                        if written > size:
-                            raise EnvironmentError("OCI blob exceeds its declared size")
-                        observed.update(chunk)
-                        output.write(chunk)
-                if written != size or "sha256:" + observed.hexdigest() != digest:
+                    with temporary.open("rb") as existing:
+                        for chunk in iter(lambda: existing.read(1024 * 1024), b""):
+                            observed.update(chunk)
+                try:
+                    response = self._request(request)
+                    if offset and response.status != 206:
+                        offset = 0
+                        written = 0
+                        observed = hashlib.sha256()
+                    if offset:
+                        content_range = response.headers.get("Content-Range", "")
+                        if not content_range.startswith(f"bytes {offset}-"):
+                            response.close()
+                            temporary.unlink(missing_ok=True)
+                            raise EnvironmentError("OCI registry returned an invalid byte range")
+                    mode = "ab" if offset else "wb"
+                    with response, temporary.open(mode) as output:
+                        while chunk := response.read(1024 * 1024):
+                            written += len(chunk)
+                            if written > size:
+                                raise EnvironmentError("OCI blob exceeds its declared size")
+                            observed.update(chunk)
+                            output.write(chunk)
+                    observed_digest = "sha256:" + observed.hexdigest()
+                    if written == size and observed_digest == digest:
+                        temporary.replace(destination)
+                        break
                     temporary.unlink(missing_ok=True)
-                    raise EnvironmentError("downloaded OCI blob failed digest verification")
-                temporary.replace(destination)
-            except urllib.error.HTTPError as exc:
-                raise DownloadUnavailable(f"OCI blob download failed: HTTP {exc.code}") from exc
-            except OSError as exc:
-                raise DownloadUnavailable(f"OCI blob download failed: {exc}") from exc
+                    if attempt == _BLOB_INTEGRITY_ATTEMPTS:
+                        raise EnvironmentError(
+                            "downloaded OCI blob failed digest verification "
+                            f"after {attempt} attempts (expected {digest}, got "
+                            f"{observed_digest}, bytes {written}/{size})"
+                        )
+                    events.emit(
+                        "library.layer_download_retry",
+                        "Retrying OCI blob after integrity verification failed",
+                        digest=digest,
+                        attempt=attempt + 1,
+                        observed_digest=observed_digest,
+                        downloaded_bytes=written,
+                        expected_bytes=size,
+                    )
+                except urllib.error.HTTPError as exc:
+                    raise DownloadUnavailable(f"OCI blob download failed: HTTP {exc.code}") from exc
+                except OSError as exc:
+                    raise DownloadUnavailable(f"OCI blob download failed: {exc}") from exc
         return destination
 
     def blob_exists(self, digest: str) -> bool:

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/lean_runtime/run_cli.py

@@ -34,6 +34,7 @@ def _progress(event: RuntimeEvent) -> None:
         "package_reference.started": "Resolving dependency",
         "library.lookup": "Looking for a cached environment",
         "library.layer_download_started": "Downloading cached environment",
+        "library.layer_download_retry": "Retrying cached-environment download",
         "environment.build_started": "Building environment",
         "environment.cache_hit": "Using local environment",
     }
@@ -314,14 +315,18 @@ def main(argv: list[str] | None = None) -> int:
                     runtime_events=runtime_events,
                 ).discover_and_check(source)
                 if discovered.status != "found" or discovered.execution_result is None:
-                    raise SpecificationError(_discovery_failure(discovered)) from None
-                if arguments.lock_out is not None:
-                    assert discovered.lock is not None
-                    discovered.lock.write(arguments.lock_out)
+                    rejection = discovered.rejection_attempt
+                    if rejection is None or rejection.execution_result is None:
+                        raise SpecificationError(_discovery_failure(discovered)) from None
+                    result = rejection.execution_result
+                else:
+                    if arguments.lock_out is not None:
+                        assert discovered.lock is not None
+                        discovered.lock.write(arguments.lock_out)
+                    result = discovered.execution_result
                 preparation = PhaseTiming(
                     "discovery", round((time.monotonic() - discovery_started) * 1000)
                 )
-                result = discovered.execution_result
         if context.lock is not None or context.toolchain is not None or not context.requires:
             result = replace(result, timings=(preparation, *result.timings))
         _emit(

{lean_runtime-2.0.5 → lean_runtime-2.0.7/lean_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.5
+Version: 2.0.7
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lean-runtime"
-version = "2.0.5"
+version = "2.0.7"
 description = "Run Lean 4 proofs from Python or standalone files"
 readme = "README.md"
 requires-python = ">=3.10"

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/schemas/execution-v1.schema.json

@@ -29,7 +29,7 @@
       "required": ["phase", "duration_ms", "performed"],
       "additionalProperties": false,
       "properties": {
-        "phase": {"enum": ["toolchain", "resolution", "source_acquisition", "cache_lookup", "cache_download", "artifact_hydration", "build", "publication", "environment_open", "instance_creation", "input_staging", "execution", "result_collection", "result_publication", "cleanup"]},
+        "phase": {"enum": ["discovery", "toolchain", "resolution", "source_acquisition", "cache_lookup", "cache_download", "artifact_hydration", "build", "publication", "environment_open", "instance_creation", "input_staging", "execution", "result_collection", "result_publication", "cleanup"]},
         "duration_ms": {"type": "integer", "minimum": 0},
         "performed": {"type": "boolean"}
       }

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/tests/discovery/test_engine.py

@@ -7,7 +7,13 @@ from dataclasses import dataclass, field
 import pytest
 
 from lean_runtime import ExecutionResult, Runtime
-from lean_runtime.discovery import Discovery, DiscoveryPolicy, PolicyError, ProbeOutcome
+from lean_runtime.discovery import (
+    Discovery,
+    DiscoveryError,
+    DiscoveryPolicy,
+    PolicyError,
+    ProbeOutcome,
+)
 from lean_runtime.discovery.candidate import Candidate
 from lean_runtime.discovery.probe import ProbeIntegrityFailure, ProbeUnavailable
 
@@ -87,6 +93,25 @@ def test_candidate_budget_never_opens_bounded_candidate(sample_catalog) -> None:
     assert probe.opened == ["mathlib-new"]
 
 
+def test_exhaustion_surfaces_the_highest_ranked_lean_rejection(sample_catalog) -> None:  # type: ignore[no-untyped-def]
+    probe = FakeProbe({"mathlib-new": execution(False, stderr="type mismatch")})
+    result = Discovery(
+        catalog=sample_catalog,
+        policy=DiscoveryPolicy(max_candidates=1),
+        probe=probe,
+    ).discover_and_check("import Mathlib\n")
+
+    assert result.status == "not_found"
+    assert result.rejection_attempt is result.attempts[0]
+    assert [item.code for item in result.diagnostics] == [
+        "DISCOVERY_CANDIDATE_LIMIT",
+        "CANDIDATE_LEAN_REJECTED",
+    ]
+    assert result.diagnostics[1].detail == "type mismatch"
+    with pytest.raises(DiscoveryError, match="type mismatch"):
+        result.raise_for_error()
+
+
 def test_unavailable_candidate_advances(sample_catalog) -> None:  # type: ignore[no-untyped-def]
     probe = FakeProbe(
         {

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/tests/test_bundles.py

@@ -18,8 +18,14 @@ import pytest
 from lean_runtime import EnvironmentError, EnvironmentLock, LockedPackage, Runtime
 from lean_runtime.bundles import _extract_layer, _oci_archive
 from lean_runtime.environments import ENVIRONMENT_SCHEMA
-from lean_runtime.oci import OCIEnvironmentPublisher, OCIRepository
-from lean_runtime.store import environment_identity, platform_record, source_snapshot_digest
+from lean_runtime.events import EventEmitter
+from lean_runtime.oci import OCIEnvironmentPublisher, OCIRegistryClient, OCIRepository
+from lean_runtime.store import (
+    EnvironmentStore,
+    environment_identity,
+    platform_record,
+    source_snapshot_digest,
+)
 
 
 def _git_package(path: Path) -> tuple[str, str]:
@@ -403,6 +409,50 @@ def test_transparent_authenticated_oci_pull_and_blob_reuse(tmp_path: Path) -> No
         thread.join(timeout=5)
 
 
+def test_oci_blob_integrity_failure_retries_once_from_scratch(tmp_path: Path) -> None:
+    data = b"verified layer contents"
+    digest = "sha256:" + hashlib.sha256(data).hexdigest()
+    requests = 0
+    cache_controls: list[str | None] = []
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self) -> None:
+            nonlocal requests
+            requests += 1
+            cache_controls.append(self.headers.get("Cache-Control"))
+            response = b"x" * len(data) if requests == 1 else data
+            self.send_response(200)
+            self.send_header("Content-Length", str(len(response)))
+            self.end_headers()
+            self.wfile.write(response)
+
+        def log_message(self, _format: str, *_args: object) -> None:
+            pass
+
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    events = []
+    try:
+        repository = OCIRepository.parse(f"oci+http://127.0.0.1:{server.server_port}/owner/cache")
+        path = OCIRegistryClient(repository).download_blob(
+            {"digest": digest, "size": len(data)},
+            EnvironmentStore(tmp_path / "consumer"),
+            EventEmitter(events.append),
+        )
+        assert path.read_bytes() == data
+        assert requests == 2
+        assert cache_controls == [None, "no-cache"]
+        assert [event.kind for event in events].count("library.layer_download_retry") == 1
+        starts = [event for event in events if event.kind == "library.layer_download_started"]
+        assert [event.data["attempt"] for event in starts] == [1, 2]
+        assert starts[1].data["resumed_bytes"] == 0
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+
+
 def test_oci_publisher_uploads_blobs_before_manifests(tmp_path: Path) -> None:
     producer, environment_id, lock = _published_runtime(tmp_path / "producer")
     publisher = OCIEnvironmentPublisher(

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/tests/test_interactive.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 import pytest
 
-from lean_runtime import EnvironmentLock, ExecutionPolicy
+from lean_runtime import EnvironmentError, EnvironmentLock, ExecutionPolicy
 from lean_runtime.backends import LocalBackend
 from lean_runtime.environments import Environment, EnvironmentManager
 from lean_runtime.store import EnvironmentStore
@@ -79,9 +79,7 @@ def test_interactive_session_round_trips_and_records_transcript(tmp_path: Path)
         execution_id = session.execution_id
         assert session.running
         assert session.poll() is None
-        session.stdin.write("hello lean\n")
-        session.stdin.flush()
-        assert session.stdout.readline() == "HELLO LEAN\n"
+        assert session.request_line("hello lean") == "HELLO LEAN"
         assert any(environment.manager.store.jobs.iterdir())
 
     result = session.close()
@@ -97,6 +95,23 @@ def test_interactive_session_round_trips_and_records_transcript(tmp_path: Path)
     assert record["operation"] == "interactive"
 
 
+def test_interactive_session_round_trips_ndjson(tmp_path: Path) -> None:
+    environment = _environment(tmp_path)
+    script = (
+        "import json, sys\n"
+        "for line in sys.stdin:\n"
+        " value = json.loads(line)\n"
+        " print(json.dumps({'id': value['id'], 'answer': value['value'] + 1}), flush=True)"
+    )
+    with environment.spawn_interactive([sys.executable, "-u", "-c", script]) as session:
+        assert session.request_json({"id": 7, "value": 41}) == {"id": 7, "answer": 42}
+        with pytest.raises(ValueError, match="exactly one line"):
+            session.send_line("first\nsecond")
+
+    with pytest.raises(EnvironmentError, match="not running"):
+        session.send_line("late request")
+
+
 def test_interactive_timeout_is_enforced_and_instance_is_removed(tmp_path: Path) -> None:
     environment = _environment(tmp_path)
     session = environment.spawn_interactive(

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/tests/test_programs.py

@@ -34,9 +34,7 @@ def test_program_identity_payload_validation_and_interactive_execution(tmp_path:
 
     assert program.id.startswith("program_")
     with program.spawn_interactive(policy=ExecutionPolicy(timeout_seconds=10)) as session:
-        session.stdin.write('{"ping":true}\n')
-        session.stdin.flush()
-        assert session.stdout.readline() == '{"ping":true}\n'
+        assert session.request_json({"ping": True}) == {"ping": True}
     assert session.close().provenance is not None
     assert session.close().provenance.program_id == program.id
 

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/tests/test_run_cli.py

@@ -1,20 +1,27 @@
+import json
 from pathlib import Path
 
 from lean_runtime import ProjectError
-from lean_runtime.models import ExecutionResult
+from lean_runtime.models import Diagnostic, ExecutionResult
 from lean_runtime.run_cli import main
 
 
-def _result() -> ExecutionResult:
+def _result(
+    *,
+    ok: bool = True,
+    stderr: str = "",
+    diagnostics: tuple[Diagnostic, ...] = (),
+) -> ExecutionResult:
     return ExecutionResult(
-        ok=True,
-        exit_code=0,
+        ok=ok,
+        exit_code=0 if ok else 1,
         toolchain="leanprover/lean4:v4.32.0",
         command=("lean", "Main.lean"),
         cwd="/tmp",
         stdout="",
-        stderr="",
+        stderr=stderr,
         elapsed_seconds=0.01,
+        diagnostics=diagnostics,
     )
 
 
@@ -158,6 +165,65 @@ def test_lean_run_discovers_standalone_file_and_writes_lock(
     assert "accepted" in capsys.readouterr().out
 
 
+def test_lean_run_preserves_discovered_compiler_rejection(
+    monkeypatch, tmp_path: Path, capsys
+) -> None:
+    source = tmp_path / "Main.lean"
+    source.write_text("import Mathlib\nexample : False := by trivial\n")
+    rejection = _result(
+        ok=False,
+        stderr="Main.lean:2:22: error: tactic 'trivial' failed",
+        diagnostics=(
+            Diagnostic(
+                "error",
+                "tactic 'trivial' failed",
+                file="Main.lean",
+                line=2,
+                column=22,
+            ),
+        ),
+    )
+
+    class NoProjectRuntime(FakeRuntime):
+        def __init__(self, **kwargs) -> None:
+            super().__init__(**kwargs)
+            self.availability = "auto"
+            self.libraries = ()
+
+        def check_file(self, *_args, **_kwargs) -> ExecutionResult:
+            raise ProjectError("no project")
+
+    class Attempt:
+        execution_result = rejection
+
+    class Rejected:
+        status = "not_found"
+        execution_result = None
+        rejection_attempt = Attempt()
+
+    class FakeDiscovery:
+        def __init__(self, **_kwargs) -> None:
+            pass
+
+        def discover_and_check(self, _source: str) -> Rejected:
+            return Rejected()
+
+    monkeypatch.setattr("lean_runtime.run_cli.Runtime", NoProjectRuntime)
+    monkeypatch.setattr("lean_runtime.run_cli.Discovery", FakeDiscovery)
+
+    assert main([str(source), "--quiet"]) == 1
+    captured = capsys.readouterr()
+    assert "tactic 'trivial' failed" in captured.err
+    assert "rejected" in captured.out
+
+    assert main([str(source), "--json", "--quiet"]) == 1
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["ok"] is False
+    assert payload["data"]["stderr"].endswith("tactic 'trivial' failed")
+    assert payload["data"]["diagnostics"][0]["message"] == "tactic 'trivial' failed"
+    assert payload["data"]["timings"][0]["phase"] == "discovery"
+
+
 def test_lean_run_can_disable_automatic_discovery(monkeypatch, tmp_path: Path, capsys) -> None:
     source = tmp_path / "Main.lean"
     source.write_text("import Mathlib\n")

{lean_runtime-2.0.5 → lean_runtime-2.0.7}/tests/test_schemas.py

@@ -58,7 +58,7 @@ def test_execution_success_fixture_matches_v1_schema() -> None:
         stdout="",
         stderr="",
         elapsed_seconds=0.01,
-        timings=(PhaseTiming("execution", 10),),
+        timings=(PhaseTiming("discovery", 5), PhaseTiming("execution", 10)),
     )
     _validator("execution-v1.schema.json").validate(serialize_execution_v1(result))