lean-runtime 3.0.0__tar.gz → 3.0.2__tar.gz

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## Unreleased
 
+## 3.0.2 - 2026-08-17
+
+- Route the first check directly through a newly downloaded slim Lean runtime.
+  Command construction and executable hashing now re-evaluate toolchain state
+  after remote acquisition and ignore incomplete Elan toolchain directories,
+  preventing cold discovery from starting an unintended full toolchain install.
+
+
+## 3.0.1 - 2026-08-17
+
+- Point the portable-copy consuming examples at
+  `ghcr.io/alerad/lean-runtime-cache`, which serves check capsules a 3.0 client
+  can read, and make the publishing examples use the `ghcr.io/OWNER/...`
+  placeholder style the other pages use. The previous
+  `ghcr.io/alerad/leancert-runtime` examples named a library that now holds only
+  pre-capsule content.
+- Make standalone discovery acquire the verified slim Lean runtime inside the
+  acquisition budget, leaving the candidate timeout exclusively for the Lean
+  compiler probe and preserving the specific timeout diagnostic.
+- Make `run --offline` genuinely retained-only: a missing exact environment
+  now fails before source materialization, Elan installation, or network
+  access.
+- Make every `run --explain --json` routing shape validate against the closed
+  `lean-runtime.inspect/v1` schema.
+- Return exit 130 with a concise message when either `lean-run` or
+  `lean-runtime run` is interrupted during preparation.
+
+
 ## 3.0.0 - 2026-08-16
 
 The first release with one canonical command vocabulary, capsule-only

{lean_runtime-3.0.0/lean_runtime.egg-info → lean_runtime-3.0.2}/PKG-INFO

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

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/docs/portable-copies.md

@@ -46,7 +46,7 @@ specification or lock:
 
 ```python
 runtime = Runtime(
-    libraries=["ghcr.io/alerad/leancert-runtime"],
+    libraries=["ghcr.io/alerad/lean-runtime-cache"],
     availability="auto",
 )
 environment = runtime.open_exact(lock)
@@ -55,7 +55,7 @@ environment = runtime.open_exact(lock)
 The equivalent environment variables are:
 
 ```bash
-export LEAN_RUNTIME_LIBRARIES=ghcr.io/alerad/leancert-runtime
+export LEAN_RUNTIME_LIBRARIES=ghcr.io/alerad/lean-runtime-cache
 export LEAN_RUNTIME_AVAILABILITY=auto
 ```
 
@@ -68,7 +68,7 @@ Explicit prefetch uses the same verified path:
 
 ```bash
 lean-runtime \
-  --library ghcr.io/alerad/leancert-runtime \
+  --library ghcr.io/alerad/lean-runtime-cache \
   download environment.lock.json
 ```
 
@@ -98,10 +98,10 @@ Actions identity:
 
 ```python
 runtime = Runtime(
-    libraries=["ghcr.io/alerad/leancert-runtime"],
+    libraries=["ghcr.io/alerad/lean-runtime-cache"],
     publisher_verification="required",
     trusted_publisher=(
-        "https://github.com/alerad/leancert/.github/workflows/cache.yml@refs/heads/main"
+        "https://github.com/alerad/lean-runtime/.github/workflows/public-cache.yml@refs/heads/main"
     ),
     trusted_issuer="https://token.actions.githubusercontent.com",
 )
@@ -121,7 +121,7 @@ Check push access without building or uploading an environment:
 
 ```bash
 lean-runtime publish environment \
-  --publish-to ghcr.io/alerad/leancert-runtime \
+  --publish-to ghcr.io/OWNER/lean-environments \
   --check-access
 ```
 
@@ -156,7 +156,7 @@ export LEAN_RUNTIME_REGISTRY_USERNAME=alerad
 export LEAN_RUNTIME_REGISTRY_PASSWORD="$GHCR_TOKEN"
 
 lean-runtime publish environment environment.lock.json \
-  --publish-to ghcr.io/alerad/leancert-runtime \
+  --publish-to ghcr.io/OWNER/lean-environments \
   --tag v4.32.2.4 \
   --sign --attest
 ```
@@ -208,7 +208,7 @@ steps:
   - uses: ./.github/actions/publish-environment
     with:
       lock: environment.lock.json
-      library: ghcr.io/${{ github.repository_owner }}/leancert-runtime
+      library: ghcr.io/${{ github.repository_owner }}/lean-environments
       tag: ${{ github.ref_name }}
       username: ${{ github.actor }}
       password: ${{ secrets.GITHUB_TOKEN }}
@@ -219,7 +219,7 @@ index and retain its JSON result:
 
 ```bash
 lean-runtime publish environment environment.lock.json \
-  --publish-to ghcr.io/alerad/leancert-runtime \
+  --publish-to ghcr.io/OWNER/lean-environments \
   --platform-only > platform-result.json
 ```
 
@@ -228,7 +228,7 @@ multi-platform index and human aliases:
 
 ```bash
 lean-runtime finalize environment "$LOCK_ID" results/*.json \
-  --library ghcr.io/alerad/leancert-runtime \
+  --library ghcr.io/OWNER/lean-environments \
   --tag "$GITHUB_REF_NAME"
 ```
 

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/docs/v1-precision.md

@@ -103,6 +103,31 @@ improve without a schema change. Other `--json` commands (for example `storage`,
 contracts. Exit code 0 means success, 1 is a completed negative
 result, and 2 is invalid invocation or an exceptional runtime failure.
 
+Schemas reference shared definitions by their canonical absolute IDs. To validate entirely
+from the installed wheel, register all packaged schemas instead of allowing a validator to
+retrieve those IDs over the network:
+
+```python
+import json
+from pathlib import Path
+
+import lean_runtime
+from jsonschema import Draft202012Validator
+from referencing import Registry, Resource
+
+documents = [
+    json.loads(lean_runtime.schema_path(name).read_text()) for name in lean_runtime.SCHEMA_NAMES
+]
+registry = Registry().with_resources(
+    (document["$id"], Resource.from_contents(document)) for document in documents
+)
+schema = next(
+    document for document in documents if document["$id"].endswith("/execution-v1.schema.json")
+)
+value = json.loads(Path("result.execution.json").read_text())
+Draft202012Validator(schema, registry=registry).validate(value)
+```
+
 ## Reproducible case study
 
 After preparing an exact environment, run:

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/discovery/api.py

@@ -58,8 +58,9 @@ class Discovery:
                 availability=availability,
                 libraries=libraries,
                 on_event=events.append,
+                allow_source_build=self.policy.allow_source_build,
             )
-        if not self.policy.allow_source_build and runtime.availability == "auto":
+        if not self.policy.allow_source_build and runtime.allow_source_build:
             raise PolicyError(
                 "the injected Runtime permits source fallback but allow_source_build is false"
             )

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/discovery/engine.py

@@ -361,11 +361,17 @@ def discover(
         if attempt.status == "lean_rejected"
         for diagnostic in attempt.diagnostics
     )
+    timeout_diagnostics = tuple(
+        diagnostic
+        for attempt in attempts
+        if attempt.status == "timeout"
+        for diagnostic in attempt.diagnostics
+    )
     return DiscoveryResult(
         status="not_found",
         confidence="exhausted",
         plan=plan,
         attempts=tuple(attempts),
         duration_seconds=time.monotonic() - started,
-        diagnostics=(reason, *rejection_diagnostics),
+        diagnostics=(*timeout_diagnostics, reason, *rejection_diagnostics),
     )

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/discovery/probe.py

@@ -94,6 +94,10 @@ class LeanRuntimeProbe:
                 import_roots=self.import_roots,
                 cancel=cancel,
             )
+            # Acquisition is complete only when the exact candidate can invoke
+            # Lean without downloading or installing anything during the
+            # compiler probe.
+            self.runtime.toolchains.ensure(candidate.entry.toolchain, cancel=cancel)
         except MaterializationError as exc:
             if exc.phase in {"lock-validation", "source-validation", "bundle-validation"}:
                 raise ProbeIntegrityFailure(str(exc)) from exc

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/oci.py

@@ -10,6 +10,7 @@ import re
 import shutil
 import subprocess
 import tempfile
+import threading
 import time
 import urllib.error
 import urllib.parse
@@ -415,6 +416,8 @@ class OCIRegistryClient:
         descriptor: dict[str, Any],
         store: EnvironmentStore,
         events: EventEmitter,
+        *,
+        cancel: threading.Event | None = None,
     ) -> Path:
         digest = descriptor.get("digest")
         size = descriptor.get("size")
@@ -422,7 +425,13 @@ class OCIRegistryClient:
         if match is None or not isinstance(size, int) or size < 0:
             raise EnvironmentError("OCI manifest contains an invalid blob descriptor")
         destination = store.oci_blobs / match.group(1)
-        with FileLock(store.lock_dir / f"oci-{match.group(1)}.lock", timeout=1800):
+        with FileLock(
+            store.lock_dir / f"oci-{match.group(1)}.lock",
+            timeout=1800,
+            cancel=cancel,
+        ):
+            if cancel is not None and cancel.is_set():
+                raise EnvironmentError("OCI blob download was cancelled")
             if destination.is_file() and destination.stat().st_size == size:
                 if _digest_path(destination) == digest:
                     events.emit(
@@ -432,6 +441,8 @@ class OCIRegistryClient:
                 destination.unlink()
             temporary = destination.with_name(f".{destination.name}.partial")
             for attempt in range(1, _BLOB_INTEGRITY_ATTEMPTS + 1):
+                if cancel is not None and cancel.is_set():
+                    raise EnvironmentError("OCI blob download was cancelled")
                 if temporary.exists() and temporary.stat().st_size > size:
                     temporary.unlink()
                 offset = temporary.stat().st_size if temporary.exists() else 0
@@ -470,6 +481,8 @@ class OCIRegistryClient:
                     last_progress = 0.0
                     with response, temporary.open(mode) as output:
                         while chunk := response.read(1024 * 1024):
+                            if cancel is not None and cancel.is_set():
+                                raise EnvironmentError("OCI blob download was cancelled")
                             written += len(chunk)
                             if written > size:
                                 raise EnvironmentError("OCI blob exceeds its declared size")

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/run_cli.py

@@ -397,13 +397,7 @@ def run(arguments: argparse.Namespace, *, command_name: str = "lean-run") -> int
             if arguments.json:
                 print(
                     json.dumps(
-                        {
-                            "schema": "lean-runtime.inspect/v1",
-                            "ok": True,
-                            "data": explanation,
-                            "warnings": [],
-                            "errors": [],
-                        },
+                        envelope("lean-runtime.inspect/v1", ok=True, data=explanation),
                         ensure_ascii=False,
                         indent=2,
                         sort_keys=True,
@@ -443,6 +437,7 @@ def run(arguments: argparse.Namespace, *, command_name: str = "lean-run") -> int
             availability=availability,
             libraries=libraries,
             max_download_bytes=arguments.max_download,
+            allow_source_build=not arguments.offline and not arguments.no_source_build,
         )
         policy = ExecutionPolicy(timeout_seconds=arguments.check_timeout)
         if context.lock is not None:
@@ -528,6 +523,10 @@ def run(arguments: argparse.Namespace, *, command_name: str = "lean-run") -> int
             show_timings=arguments.timings,
         )
         return 0 if result.ok else 1
+    except KeyboardInterrupt:
+        renderer.close()
+        print(f"{command_name}: interrupted", file=sys.stderr)
+        return 130
     except (DiscoveryError, LeanRuntimeError, OSError, UnicodeError, ValueError) as exc:
         renderer.close()
         if arguments.json:

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/runtime.py

@@ -209,6 +209,7 @@ class Runtime:
         availability: str | None = None,
         libraries: Sequence[str] | None = None,
         max_download_bytes: int | None = None,
+        allow_source_build: bool = True,
         publisher_verification: str = "ignore",
         trusted_publisher: str | None = None,
         trusted_issuer: str | None = None,
@@ -255,6 +256,7 @@ class Runtime:
                 else DEFAULT_ENVIRONMENT_LIBRARIES
             )
         self.availability = availability
+        self.allow_source_build = allow_source_build
         self.max_download_bytes = max_download_bytes
         self.verification_executable = verification_tool
         self.signature_verifier = (
@@ -286,7 +288,11 @@ class Runtime:
         self.toolchains.remote_ensure = self._acquire_check_toolchain
         self.environments.sparse_acquirer = self._acquire_sparse_modules
 
-    def _acquire_check_toolchain(self, toolchain: str) -> bool:
+    def _acquire_check_toolchain(
+        self,
+        toolchain: str,
+        cancel: threading.Event | None = None,
+    ) -> bool:
         if self.availability == "local":
             raise ToolchainError(
                 f"toolchain {normalize_toolchain(toolchain)!r} is not available locally; "
@@ -294,7 +300,7 @@ class Runtime:
             )
         for library in self.toolchain_libraries:
             try:
-                return library.pull(toolchain)
+                return library.pull(toolchain, cancel=cancel)
             except DownloadUnavailable:
                 continue
         return False
@@ -347,6 +353,7 @@ class Runtime:
     ) -> Environment:
         environment_id = environment_identity(lock, build_profile)
         destination = self.store.environment_path(environment_id)
+        imported = False
         if self.max_download_bytes is not None and self.availability != "local":
             preflight = self.plan_exact(
                 lock,
@@ -377,7 +384,6 @@ class Runtime:
                     "lean-run --plan"
                 )
         if not destination.is_dir() and self.availability != "local":
-            imported = False
             rejections: list[str] = []
             for library in self.libraries:
                 try:
@@ -412,6 +418,12 @@ class Runtime:
                     capability="source_build",
                     environment_id=environment_id,
                 )
+        if not destination.is_dir() and not imported and not self.allow_source_build:
+            raise EnvironmentError(
+                f"environment {environment_id} is not retained locally; offline mode "
+                "does not permit downloading, toolchain installation, or source "
+                "materialization"
+            )
         return self.environments.ensure(
             lock,
             name=name,

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/toolchain_oci.py

@@ -10,6 +10,7 @@ import shutil
 import subprocess
 import tarfile
 import tempfile
+import threading
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
 from typing import Any
@@ -314,16 +315,35 @@ class OCIToolchainLibrary:
             dict(config["slim_manifest"]),
         )
 
-    def pull(self, toolchain: str) -> bool:
+    def pull(
+        self,
+        toolchain: str,
+        *,
+        cancel: threading.Event | None = None,
+    ) -> bool:
         local_check = getattr(self.toolchains, "is_available_locally", None)
         if callable(local_check) and local_check(toolchain):
             return True
         plan = self.plan(toolchain)
         self.client.cache_verified_blob(plan.config_data, plan.config_descriptor, self.store)
-        layer = self.client.download_blob(plan.descriptor, self.store, self.events)
+        try:
+            layer = self.client.download_blob(
+                plan.descriptor,
+                self.store,
+                self.events,
+                cancel=cancel,
+            )
+        except EnvironmentError as exc:
+            if cancel is not None and cancel.is_set():
+                raise ToolchainError(
+                    f"Lean toolchain download was cancelled: {normalize_toolchain(toolchain)!r}"
+                ) from exc
+            raise
         destination = self.toolchains.slim_path(toolchain)
         with FileLock(
-            self.store.lock_dir / f"toolchain-{toolchain_reference(toolchain)}.lock", timeout=1800
+            self.store.lock_dir / f"toolchain-{toolchain_reference(toolchain)}.lock",
+            timeout=1800,
+            cancel=cancel,
         ):
             if self.toolchains.is_available_locally(toolchain):
                 return True

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/lean_runtime/toolchains.py

@@ -81,7 +81,7 @@ class ToolchainManager:
         self.home = Path(home).expanduser().resolve() if home else default_runtime_home()
         self.elan_home = self.home / "elan"
         self.events = events or EventEmitter()
-        self.remote_ensure: Callable[[str], bool] | None = None
+        self.remote_ensure: Callable[[str, threading.Event | None], bool] | None = None
         self._executable_digests: dict[str, tuple[int, int, str]] = {}
 
     @property
@@ -264,7 +264,7 @@ class ToolchainManager:
         name = normalize_toolchain(toolchain)
         if self.has_slim(name) or (self._elan_toolchain_dir(name) / "bin" / "lean").is_file():
             return name
-        if self.remote_ensure is not None and self.remote_ensure(name):
+        if self.remote_ensure is not None and self.remote_ensure(name, cancel):
             if not self.has_slim(name):
                 raise ToolchainError("remote toolchain acquisition returned without a slim copy")
             return name
@@ -325,26 +325,33 @@ class ToolchainManager:
         A full Elan installation is preferred; when only a verified slim copy
         remains, its executables are invoked directly.
         """
-        name = normalize_toolchain(toolchain)
-        if self.has_slim(name) and not self._elan_toolchain_dir(name).is_dir():
+        name = self.ensure(toolchain)
+        full = self._elan_toolchain_dir(name)
+        full_lean = full / "bin" / "lean"
+        if os.name == "nt":
+            full_lean = full_lean.with_suffix(".exe")
+        if self.has_slim(name) and not full_lean.is_file():
             binary = self.slim_path(name) / "bin" / executable
+            if os.name == "nt":
+                binary = binary.with_suffix(".exe")
             if not binary.is_file():
                 raise ToolchainError(
                     f"slim toolchain {name!r} does not provide {executable!r}; "
                     "reinstall the full toolchain for this operation"
                 )
             return [str(binary), *args]
-        name = self.ensure(name)
         return [str(self.elan_path()), "run", name, executable, *args]
 
     def executable_digest(self, toolchain: str, executable: str) -> str:
         """Hash the exact resolved executable for compatibility-cache identities."""
-        name = normalize_toolchain(toolchain)
+        name = self.ensure(toolchain)
         full = self._elan_toolchain_dir(name)
-        if self.has_slim(name) and not full.is_dir():
+        full_lean = full / "bin" / "lean"
+        if os.name == "nt":
+            full_lean = full_lean.with_suffix(".exe")
+        if self.has_slim(name) and not full_lean.is_file():
             binary = self.slim_path(name) / "bin" / executable
         else:
-            self.ensure(name)
             binary = full / "bin" / executable
         if os.name == "nt" and not binary.is_file():
             binary = binary.with_suffix(".exe")

{lean_runtime-3.0.0 → lean_runtime-3.0.2/lean_runtime.egg-info}/PKG-INFO

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

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/pyproject.toml

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

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/schemas/inspect-v1.schema.json

@@ -8,8 +8,19 @@
     "schema": {"const": "lean-runtime.inspect/v1"},
     "ok": {"type": "boolean"},
     "data": {
+      "oneOf": [
+        {"$ref": "#/$defs/inspectionData"},
+        {"$ref": "#/$defs/routingData"},
+        {"type": "object", "maxProperties": 0}
+      ]
+    },
+    "warnings": {"$ref": "https://lean-runtime.dev/schemas/execution-v1.schema.json#/$defs/issues"},
+    "errors": {"$ref": "https://lean-runtime.dev/schemas/execution-v1.schema.json#/$defs/issues"}
+  },
+  "$defs": {
+    "inspectionData": {
       "type": "object",
-      "anyOf": [{"required": ["subject", "subject_kind", "lock_id", "environment", "package_locks", "decisions"]}, {"maxProperties": 0}],
+      "required": ["subject", "subject_kind", "lock_id", "environment", "package_locks", "decisions"],
       "additionalProperties": false,
       "properties": {
         "subject": {"type": "string"},
@@ -20,10 +31,22 @@
         "decisions": {"type": "array", "items": {"$ref": "#/$defs/decision"}}
       }
     },
-    "warnings": {"$ref": "https://lean-runtime.dev/schemas/execution-v1.schema.json#/$defs/issues"},
-    "errors": {"$ref": "https://lean-runtime.dev/schemas/execution-v1.schema.json#/$defs/issues"}
-  },
-  "$defs": {
+    "routingData": {
+      "type": "object",
+      "required": ["decision", "context", "subject"],
+      "additionalProperties": false,
+      "properties": {
+        "decision": {"enum": ["context_selected", "automatic_discovery"]},
+        "context": {"type": "string"},
+        "subject": {
+          "oneOf": [
+            {"type": "string"},
+            {"type": "array", "items": {"type": "string"}, "uniqueItems": true}
+          ]
+        },
+        "plan": {"type": "object"}
+      }
+    },
     "environment": {
       "type": "object",
       "required": ["environment_id", "lock_id", "toolchain", "packages", "platform", "build_profile", "status", "created_at", "names"],

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/tests/discovery/test_engine.py

@@ -222,6 +222,8 @@ def test_per_candidate_timeout_is_enforced(sample_catalog) -> None:  # type: ign
     ).discover_and_check("import Mathlib\n")
     assert result.status == "not_found"
     assert result.attempts[0].status == "timeout"
+    assert result.diagnostics[0].code == "CANDIDATE_TIMEOUT"
+    assert "time budget" in result.diagnostics[0].detail
     assert result.duration_seconds < 0.5
 
 
@@ -305,6 +307,17 @@ def test_lean_runtime_probe_passes_the_acquisition_budget_to_builds(sample_catal
 
     captured: dict[str, float] = {}
 
+    class Toolchains:
+        def ensure(
+            self,
+            toolchain: str,
+            *,
+            cancel: threading.Event | None = None,
+        ) -> str:
+            assert cancel is not None
+            captured["toolchain_ready"] = 1
+            return toolchain
+
     def open_exact(  # type: ignore[no-untyped-def]
         lock, *, build_timeout, import_roots=(), cancel=None
     ):
@@ -312,11 +325,16 @@ def test_lean_runtime_probe_passes_the_acquisition_budget_to_builds(sample_catal
         captured["build_timeout"] = build_timeout
         return SimpleNamespace(id="env_fake")
 
-    runtime = SimpleNamespace(open_exact=open_exact, availability="auto")
+    runtime = SimpleNamespace(
+        open_exact=open_exact,
+        availability="auto",
+        toolchains=Toolchains(),
+    )
     probe = LeanRuntimeProbe(runtime=runtime)  # type: ignore[arg-type]
     candidate = Discovery(catalog=sample_catalog).plan("import Mathlib\n").candidates[0]
     acquired = probe.acquire(candidate, timeout_seconds=123.0, cancel=threading.Event())
     assert captured["build_timeout"] == 123.0
+    assert captured["toolchain_ready"] == 1
     assert acquired.environment_id == "env_fake"
 
 

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/tests/test_bundles.py

@@ -657,6 +657,21 @@ def test_oci_blob_integrity_failure_retries_once_from_scratch(tmp_path: Path) ->
         thread.join(timeout=5)
 
 
+def test_oci_blob_download_honors_preexisting_cancellation(tmp_path: Path) -> None:
+    cancel = threading.Event()
+    cancel.set()
+    store = EnvironmentStore(tmp_path / "consumer")
+    repository = OCIRepository.parse("oci+http://127.0.0.1:1/owner/cache")
+    with pytest.raises(EnvironmentError, match="cancelled"):
+        OCIRegistryClient(repository).download_blob(
+            {"digest": "sha256:" + "a" * 64, "size": 1},
+            store,
+            EventEmitter(),
+            cancel=cancel,
+        )
+    assert not list(store.oci_blobs.iterdir())
+
+
 def _publish_full_layout(monkeypatch: pytest.MonkeyPatch) -> None:
     """Let publisher transport tests skip capsule construction.
 

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/tests/test_prebuilt_policy.py

@@ -102,6 +102,29 @@ def test_require_rejects_missing_cache_configuration(tmp_path: Path) -> None:
         runtime.open_exact(_lock())
 
 
+def test_retained_only_open_rejects_before_materialization(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    runtime = Runtime(
+        home=tmp_path,
+        availability="local",
+        libraries=[],
+        allow_source_build=False,
+    )
+    called = False
+
+    def materialize(*_args: object, **_kwargs: object) -> object:
+        nonlocal called
+        called = True
+        return object()
+
+    monkeypatch.setattr(runtime.environments, "ensure", materialize)
+    with pytest.raises(EnvironmentError, match="not retained locally"):
+        runtime.open_exact(_lock())
+    assert not called
+    assert not runtime.toolchains.elan_home.exists()
+
+
 def test_registry_redirect_does_not_forward_authorization_cross_host() -> None:
     request = urllib.request.Request("https://registry.example/v2/owner/cache/blobs/sha256:x")
     request.add_header("Authorization", "Bearer secret")

{lean_runtime-3.0.0 → lean_runtime-3.0.2}/tests/test_run_cli.py

@@ -483,6 +483,31 @@ def test_run_subcommand_rejects_contradictory_availability(
     assert "--offline cannot be combined" in capsys.readouterr().err
 
 
+def test_offline_run_disables_source_materialization(monkeypatch, tmp_path: Path) -> None:
+    source = tmp_path / "Main.lean"
+    source.write_text("example : True := by trivial\n")
+    monkeypatch.setattr("lean_runtime.run_cli.Runtime", FakeRuntime)
+    assert main([str(source), "--toolchain", "v4.32.2", "--offline", "--quiet"]) == 0
+    assert FakeRuntime.instance.kwargs["availability"] == "local"
+    assert FakeRuntime.instance.kwargs["libraries"] == ()
+    assert FakeRuntime.instance.kwargs["allow_source_build"] is False
+
+
+def test_lean_run_interrupt_has_no_traceback(monkeypatch, tmp_path: Path, capsys) -> None:
+    source = tmp_path / "Main.lean"
+    source.write_text("example : True := by trivial\n")
+
+    class InterruptedRuntime:
+        def __init__(self, **_kwargs) -> None:
+            raise KeyboardInterrupt
+
+    monkeypatch.setattr("lean_runtime.run_cli.Runtime", InterruptedRuntime)
+    assert main([str(source), "--toolchain", "v4.32.2"]) == 130
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert captured.err == "lean-run: interrupted\n"
+
+
 def test_run_subcommand_forwards_global_libraries(monkeypatch, tmp_path: Path) -> None:
     from lean_runtime.cli import main as lean_runtime_main