lean-runtime 4.22.0__tar.gz → 4.23.0__tar.gz

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+## 4.23.0 - 2026-08-24
+
 ## 4.22.0 - 2026-08-23
 
 ## 4.21.0 - 2026-08-23

{lean_runtime-4.22.0/lean_runtime.egg-info → lean_runtime-4.23.0}/PKG-INFO

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

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime/cli.py

@@ -119,18 +119,20 @@ def _render_storage(status: StoreStatus) -> None:
         ("Executions", status.executions, status.executions_bytes),
         ("Scratch", status.scratch_workspaces, status.scratch_bytes),
     )
+    label_width = max(len(label) for label, _count, _bytes in rows)
+    count_width = max(8, *(len(str(count)) for _label, count, _bytes in rows if count is not None))
     for label, count, bytes_used in rows:
-        counted = f"{count:>5}" if count is not None else "     "
+        counted = f"{count:>{count_width}}" if count is not None else " " * count_width
         size_column = style.cyan(f"{format_byte_size(bytes_used):>10}")
-        print(f"  {label:<15}{counted}  {size_column}")
-    total_label = style.bold(f"{'Materialized':<15}")
+        print(f"  {label:<{label_width}} {counted}  {size_column}")
+    total_label = style.bold(f"{'Materialized':<{label_width}}")
     total_size = style.bold(f"{format_byte_size(status.bytes_used):>10}")
     free_note = style.dim(f"({format_byte_size(status.bytes_free)} free on disk)")
-    print(f"  {total_label}       {total_size}  {free_note}")
+    print(f"  {total_label} {' ' * count_width}  {total_size}  {free_note}")
     if status.allocated_bytes:
-        allocated_label = style.bold(f"{'Allocated*':<15}")
+        allocated_label = style.bold(f"{'Allocated*':<{label_width}}")
         allocated_size = style.bold(f"{format_byte_size(status.allocated_bytes):>10}")
-        print(f"  {allocated_label}       {allocated_size}")
+        print(f"  {allocated_label} {' ' * count_width}  {allocated_size}")
         print(style.dim("  * hard links counted once; copy-on-write blocks may still be shared"))
     if status.environment_usage:
         print()
@@ -886,6 +888,13 @@ Advanced namespaces:
     adopt.add_argument(
         "--dry-run", action="store_true", help="show the adoption plan without changing anything"
     )
+    adopt.add_argument(
+        "--no-agents",
+        dest="agents",
+        action="store_false",
+        default=True,
+        help="skip generating AGENTS.md",
+    )
     _add_common_output(adopt)
     adopt.set_defaults(command="attach", recursive=None, execute=False)
 
@@ -1150,6 +1159,13 @@ Advanced namespaces:
     pshare.add_argument(
         "--dry-run", action="store_true", help="show the sharing plan without changing anything"
     )
+    pshare.add_argument(
+        "--no-agents",
+        dest="agents",
+        action="store_false",
+        default=True,
+        help="skip generating AGENTS.md",
+    )
     _add_common_output(pshare)
     pshare.set_defaults(command="attach", recursive=None, execute=False)
     punshare = pc.add_parser("unshare", help="materialize independent dependency copies")
@@ -1679,9 +1695,19 @@ def main(argv: list[str] | None = None) -> int:
                 if args.agents:
                     print(f"Agent guide: {init_result.root / 'AGENTS.md'}")
                 project_name = init_plan.project_name or init_result.root.name
-                print(
-                    f"Next: cd {init_result.root} && lean-runtime check {project_name}/Basic.lean"
+                # Lake capitalizes the module directory during `lake init`, so derive
+                # the hint from the file it actually created rather than the raw name.
+                created = sorted(
+                    path
+                    for path in init_result.root.glob("*/Basic.lean")
+                    if not path.parent.name.startswith(".")
                 )
+                module_file = (
+                    created[0].relative_to(init_result.root)
+                    if created
+                    else Path(project_name) / "Basic.lean"
+                )
+                print(f"Next: cd {init_result.root} && lean-runtime check {module_file}")
             return 0
         if args.command == "scan":
             scan_result = runtime.scan_projects(args.path, recursive=args.recursive)
@@ -1793,8 +1819,24 @@ def main(argv: list[str] | None = None) -> int:
                 recursive=args.recursive,
                 plan=adoption_plan,
             )
+            # Adoption is the canonical moment a repository becomes agent-ready,
+            # including re-runs against already-attached projects.
+            agent_guides = (
+                [
+                    guide
+                    for attached in adoption_result.results
+                    if (guide := runtime.write_agents_guide(attached.root)) is not None
+                ]
+                if args.agents
+                else []
+            )
             if args.json:
-                _json(adoption_result.to_dict())
+                _json(
+                    {
+                        **adoption_result.to_dict(),
+                        "agent_guides": [str(guide) for guide in agent_guides],
+                    }
+                )
             else:
                 _render_adoption_plan(adoption_result.plan)
                 for attached in adoption_result.results:
@@ -1802,6 +1844,8 @@ def main(argv: list[str] | None = None) -> int:
                         f"{attached.action}: {attached.root} · "
                         f"{format_byte_size(attached.reclaimed_bytes)} replaced"
                     )
+                for guide in agent_guides:
+                    print(f"Agent guide: {guide}")
                 for root, message in adoption_result.failures:
                     print(f"failed: {root}: {message}", file=sys.stderr)
             return 0 if adoption_result.ok else 1
@@ -1958,6 +2002,10 @@ def main(argv: list[str] | None = None) -> int:
                 name=args.name,
                 build_timeout=args.timeout,
                 accelerate=args.accelerate,
+                # Acquire means the whole environment: demanding the root
+                # module keeps a sparse capsule from satisfying it with an
+                # empty closure that only looks ready.
+                import_roots=(ROOT_MODULE,),
             )
             _json(environment.inspect().to_dict())
             if args.timings:
@@ -2252,12 +2300,22 @@ def main(argv: list[str] | None = None) -> int:
                     "toolchain": project_status.toolchain,
                     "manifest": str(project_status.manifest) if project_status.manifest else None,
                     "attached": (project_status.root / "lean-runtime.toml").is_file(),
+                    "agents_guide": (
+                        str(project_status.root / "AGENTS.md")
+                        if (project_status.root / "AGENTS.md").is_file()
+                        else None
+                    ),
                 }
             if args.json:
                 _json(status_payload)
             else:
-                print(f"{status_payload['kind'].title()}")
-                for key, value in status_payload.items():
+                display_payload = dict(status_payload)
+                if display_payload.get("kind") == "project" and (
+                    display_payload.get("agents_guide") is None
+                ):
+                    display_payload["agents_guide"] = "missing (`lean-runtime adopt` writes one)"
+                print(f"{display_payload['kind'].title()}")
+                for key, value in display_payload.items():
                     if key == "kind":
                         continue
                     label = key.replace("_", " ").title()
@@ -2547,7 +2605,7 @@ def main(argv: list[str] | None = None) -> int:
                 watched = Path(args.inputs[0]).expanduser().resolve()
                 if not watched.is_file():
                     raise ValueError(f"watched Lean file does not exist: {watched}")
-                print(f"Watching {watched} · Ctrl-C to stop")
+                print(f"Watching {watched} · Ctrl-C to stop", flush=True)
                 if os.environ.get(_HEADER_SNAPSHOTS_VARIABLE) is None:
                     runtime.header_cache.enabled = True
                 previous: tuple[int, int] | None = None
@@ -2563,6 +2621,7 @@ def main(argv: list[str] | None = None) -> int:
                             policy=_policy(args),
                         )
                         _emit_result(watched_result, False)
+                        sys.stdout.flush()
                     time.sleep(args.watch_interval)
             check_subject = (
                 Path(args.inputs[-1]).name
@@ -2614,10 +2673,16 @@ def main(argv: list[str] | None = None) -> int:
                     if args.include:
                         raise ValueError("local project checks do not accept --include")
                     display_path = "<stdin>"
+                    stdin_project = args.project
+                    if stdin_project is None and args.toolchain is None:
+                        try:
+                            stdin_project = discover_project(Path.cwd()).root
+                        except ProjectNotFoundError:
+                            stdin_project = None
                     result = runtime.check(
                         sys.stdin.read(),
                         toolchain=args.toolchain,
-                        project=args.project,
+                        project=stdin_project,
                         policy=_policy(args),
                     )
                     source_file = None

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime/discovery/engine.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import re
 import threading
 import time
 
 from ..errors import LeanRuntimeError
-from .candidate import DiscoveryPlan
+from ..models import ExecutionResult
+from .candidate import Candidate, DiscoveryPlan
+from .catalog import CatalogEntry
 from .probe import CandidateProbe, ProbeIntegrityFailure, ProbeUnavailable
 from .result import (
     AttemptStatus,
@@ -27,6 +30,8 @@ DISCOVERY_EXHAUSTED = "DISCOVERY_EXHAUSTED"
 DISCOVERY_EXPLICIT_LOCK = "DISCOVERY_EXPLICIT_LOCK"
 DISCOVERY_CANCELLED = "DISCOVERY_CANCELLED"
 DISCOVERY_RUNTIME_ERROR = "DISCOVERY_RUNTIME_ERROR"
+DISCOVERY_MODULE_UNAVAILABLE = "DISCOVERY_MODULE_UNAVAILABLE"
+DISCOVERY_VERDICT_BOUNDED = "DISCOVERY_VERDICT_BOUNDED"
 CANDIDATE_LEAN_REJECTED = "CANDIDATE_LEAN_REJECTED"
 CANDIDATE_UNAVAILABLE = "CANDIDATE_UNAVAILABLE"
 CANDIDATE_INTEGRITY_FAILURE = "CANDIDATE_INTEGRITY_FAILURE"
@@ -145,6 +150,63 @@ def _rejection_detail(stderr: str, stdout: str) -> str:
     return stderr.strip() or stdout.strip() or "Lean rejected the source"
 
 
+# Lean reports a missing import as `unknown module prefix 'X'` (directory-shaped
+# roots) or `unknown module 'X'`; both are decidable against candidate
+# inventories without running another compiler.
+_UNKNOWN_MODULE = re.compile(r"unknown module(?: prefix)? '([^']+)'")
+# Identifier-level failures are the rejection class where an older environment
+# legitimately changes the verdict (renamed or deleted lemmas), so they always
+# justify continuing the candidate march.
+_IDENTIFIER_MARKERS = ("unknown identifier", "unknown constant")
+# Positive evidence that the source itself is the problem. Kept deliberately
+# narrow: anything unrecognized preserves the ordinary march.
+_PROOF_LEVEL_MARKERS = ("type mismatch", "unsolved goals", "unexpected token")
+
+
+def _provides_module(entry: CatalogEntry, name: str) -> bool:
+    return name in entry.modules or any(module.startswith(name + ".") for module in entry.modules)
+
+
+def _rejection_verdict(
+    result: ExecutionResult, candidates: tuple[Candidate, ...]
+) -> tuple[str, tuple[str, ...]]:
+    """Classify whether another candidate environment could change a rejection.
+
+    Returns one of:
+    - ``("module_unavailable", names)``: the source imports module roots that no
+      planned candidate provides; every further attempt must fail identically.
+    - ``("source_verdict", ())``: a proof-level failure (type mismatch,
+      unsolved goals, syntax); a second opinion never justifies a fresh
+      download — only local environments or an offline plan's source builds.
+    - ``("march", ())``: everything else — identifier-level failures, modules
+      another candidate does provide, and unclassifiable output all keep the
+      ordinary bounded march.
+    """
+    text = "\n".join(
+        (
+            *(item.message for item in result.diagnostics),
+            result.stderr,
+            result.stdout,
+        )
+    )
+    missing = tuple(dict.fromkeys(_UNKNOWN_MODULE.findall(text)))
+    if missing:
+        unavailable = tuple(
+            name
+            for name in missing
+            if not any(_provides_module(candidate.entry, name) for candidate in candidates)
+        )
+        if unavailable:
+            return "module_unavailable", unavailable
+        return "march", ()
+    lowered = text.lower()
+    if any(marker in lowered for marker in _IDENTIFIER_MARKERS):
+        return "march", ()
+    if any(marker in lowered for marker in _PROOF_LEVEL_MARKERS):
+        return "source_verdict", ()
+    return "march", ()
+
+
 def discover(
     source: str,
     plan: DiscoveryPlan,
@@ -189,6 +251,11 @@ def discover(
         raise ValueError("an authoritative candidate probe is required")
     attempts: list[CandidateAttempt] = []
     remote_acquisitions = 0
+    # Set once a proof-level rejection shows the source itself is the problem:
+    # remaining candidates are only worth a look when reaching them costs no
+    # download (already local, or an offline plan's deliberate source builds).
+    local_candidates_only = False
+    verdict_bounded_skips = 0
     for candidate in plan.planned_candidates:
         if cancel is not None and cancel.is_set():
             return DiscoveryResult(
@@ -217,6 +284,12 @@ def discover(
         candidate_is_local = any(
             reason.code == "RANK_LOCAL_AVAILABLE" for reason in candidate.reasons
         )
+        # A proof-level rejection never justifies a *download*. Offline plans
+        # (allow_download=False) acquire candidates by deliberate local source
+        # builds, so their march is preserved in full.
+        if local_candidates_only and not candidate_is_local and plan.policy.allow_download:
+            verdict_bounded_skips += 1
+            continue
         if not candidate_is_local and remote_acquisitions >= plan.policy.max_remote_acquisitions:
             return DiscoveryResult(
                 status="not_found",
@@ -427,6 +500,29 @@ def discover(
                 duration_seconds=time.monotonic() - started,
                 diagnostics=attempt.diagnostics,
             )
+        if outcome_status == "lean_rejected":
+            verdict, unavailable = _rejection_verdict(result, plan.planned_candidates)
+            if verdict == "module_unavailable":
+                # Statically decidable: no candidate can change this verdict.
+                return DiscoveryResult(
+                    status="not_found",
+                    confidence="exhausted",
+                    outcome="source_rejected",
+                    completion="complete",
+                    plan=plan,
+                    attempts=tuple(attempts),
+                    duration_seconds=time.monotonic() - started,
+                    diagnostics=(
+                        ResultDiagnostic(
+                            DISCOVERY_MODULE_UNAVAILABLE,
+                            "no cataloged environment provides module(s): "
+                            + ", ".join(unavailable),
+                        ),
+                        *attempt.diagnostics,
+                    ),
+                )
+            if verdict == "source_verdict":
+                local_candidates_only = True
 
     if time.monotonic() >= wall_deadline or probe_remaining <= 0:
         reason = ResultDiagnostic(DISCOVERY_TIME_LIMIT, "total wall-clock budget expired")
@@ -465,6 +561,17 @@ def discover(
         if attempt.status == "timeout"
         for diagnostic in attempt.diagnostics
     )
+    skip_diagnostics = (
+        (
+            ResultDiagnostic(
+                DISCOVERY_VERDICT_BOUNDED,
+                f"skipped {verdict_bounded_skips} non-local candidate(s): a proof-level "
+                "rejection does not justify downloading further environments",
+            ),
+        )
+        if verdict_bounded_skips
+        else ()
+    )
     return DiscoveryResult(
         status="not_found",
         confidence=confidence,
@@ -473,5 +580,5 @@ def discover(
         plan=plan,
         attempts=tuple(attempts),
         duration_seconds=time.monotonic() - started,
-        diagnostics=(*timeout_diagnostics, reason, *rejection_diagnostics),
+        diagnostics=(*timeout_diagnostics, reason, *skip_diagnostics, *rejection_diagnostics),
     )

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime/oci.py

@@ -887,6 +887,17 @@ class OCIEnvironmentCache:
         capsule = CapsuleManifest.from_dict(config["capsule"])
         if capsule.lock_id != lock.lock_id or capsule.toolchain != lock.toolchain:
             raise EnvironmentError("downloadable capsule does not match its lock")
+        # A capsule that lacks a requested root cannot satisfy this acquisition;
+        # silently projecting a partial closure would yield an environment that
+        # claims readiness while missing the modules the caller asked for.
+        available = {module.name for module in capsule.modules}
+        unavailable = tuple(root for root in roots if root not in available)
+        if unavailable:
+            raise DownloadUnavailable(
+                "downloadable capsule does not provide module(s): " + ", ".join(unavailable),
+                reason_code="capsule_roots_unavailable",
+                retryable=False,
+            )
         closure = capsule.closure(roots)
         module_names = tuple(module.name for module in closure)
         descriptors = {

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime/project_execution.py

@@ -9,6 +9,7 @@ its artifact cache without changing the public ``Runtime`` API.
 
 from __future__ import annotations
 
+import json
 import os
 import re
 import subprocess
@@ -17,6 +18,7 @@ import tempfile
 import threading
 import time
 from collections.abc import Callable, Sequence
+from contextlib import AbstractContextManager, nullcontext
 from dataclasses import replace
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -28,6 +30,7 @@ else:  # pragma: no cover - exercised by the Python 3.10 CI job
 
 from .errors import ProjectError
 from .import_syntax import IMPORT_STATEMENT
+from .locking import FileLock
 from .models import ExecutionResult, PhaseTiming
 from .policies import ExecutionPolicy
 from .project_sharing import project_sharing_enabled
@@ -91,6 +94,63 @@ class ProjectExecutor:
     def __init__(self, runtime: Runtime) -> None:
         self.runtime = runtime
 
+    @staticmethod
+    def _declares_dependencies(context: ProjectContext) -> bool:
+        """Whether the lakefile requires packages Lake would have to fetch."""
+        try:
+            text = context.lakefile.read_text(encoding="utf-8")
+        except OSError:
+            return False
+        if context.lakefile.name == "lakefile.toml":
+            try:
+                return bool(tomllib.loads(text).get("require"))
+            except tomllib.TOMLDecodeError:
+                return False
+        return any(line.lstrip().startswith("require ") for line in text.splitlines())
+
+    @staticmethod
+    def _packages_materialized(root: Path, manifest: Path) -> bool:
+        """Whether every manifest package already has a checkout on disk."""
+        try:
+            document = json.loads(manifest.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return True  # let Lake report the manifest problem itself
+        packages = document.get("packages")
+        if not isinstance(packages, list):
+            return True
+        packages_dir = root / str(document.get("packagesDir", ".lake/packages"))
+        for package in packages:
+            name = package.get("name") if isinstance(package, dict) else None
+            if isinstance(name, str) and name and not (packages_dir / name).exists():
+                return False
+        return True
+
+    def _bootstrap_guard(self, context: ProjectContext) -> AbstractContextManager[object]:
+        """Never let a check implicitly resolve dependencies, and never in parallel.
+
+        A missing manifest with declared dependencies means ``lake env`` would
+        run an implicit ``lake update`` — cloning and compiling dependencies
+        from source, which is Lake's job to do once, deliberately. Concurrent
+        checks against a manifest whose packages are not yet materialized race
+        Lake's checkout of the same directories, so exactly one check may run
+        until the packages exist.
+        """
+        manifest = context.current_manifest()
+        if manifest is None:
+            if self._declares_dependencies(context):
+                raise ProjectError(
+                    f"{context.root} declares dependencies but has no lake-manifest.json; "
+                    "run `lake update` once to resolve versions, then `lean-runtime build` "
+                    "to restore shared dependency artifacts"
+                )
+        elif self._packages_materialized(context.root, manifest):
+            return nullcontext()
+        return FileLock(
+            context.root / ".lake" / "lean-runtime" / "bootstrap.lock",
+            timeout=3600,
+            owner={"operation": "project_bootstrap", "root": str(context.root)},
+        )
+
     def _checked_with_header_snapshots(
         self,
         context: ProjectContext,
@@ -162,7 +222,8 @@ class ProjectExecutor:
                 context, provenance.workspace_digest, relative, text, command, execute, cancel
             )
 
-        result = self._build_missing_local_import(context, text, run(), run, policy, cancel)
+        with self._bootstrap_guard(context):
+            result = self._build_missing_local_import(context, text, run(), run, policy, cancel)
         return self._with_identifier_hints(context, result)
 
     def check_source(
@@ -213,7 +274,10 @@ class ProjectExecutor:
                     cancel,
                 )
 
-            result = self._build_missing_local_import(context, source, run(), run, policy, cancel)
+            with self._bootstrap_guard(context):
+                result = self._build_missing_local_import(
+                    context, source, run(), run, policy, cancel
+                )
             return self._with_identifier_hints(context, result)
 
     def _build_missing_local_import(

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime/run_cli.py

@@ -199,7 +199,12 @@ def _discovery_failure(result: DiscoveryResult) -> str:
     return (details[0] if details else "no compatible environment was found") + suffix
 
 
-def _discovery_summary(result: DiscoveryResult) -> str:
+def _discovery_summary(result: DiscoveryResult) -> str | None:
+    # A finished search that ends in a compiler rejection needs no epilogue:
+    # an environment was found and the verdict is the diagnostic above. Only
+    # an *incomplete* search (a limit stopped it) is worth a trailing line.
+    if result.outcome == "source_rejected" and result.completion == "complete":
+        return None
     tested = len(result.attempts)
     planned = len(getattr(result.plan, "planned_candidates", result.plan.candidates))
     untried = max(0, planned - tested)
@@ -592,10 +597,13 @@ def run(
             )
         if context_resolution.kind in {"lock", "toolchain", "project", "discovery"}:
             result = replace(result, timings=(preparation, *result.timings))
-        if rejected_discovery is not None:
+        discovery_summary = (
+            _discovery_summary(rejected_discovery) if rejected_discovery is not None else None
+        )
+        if discovery_summary is not None:
             result = replace(
                 result,
-                hints=(*result.hints, _discovery_summary(rejected_discovery)),
+                hints=(*result.hints, discovery_summary),
             )
         renderer.close()
         _emit(
@@ -607,9 +615,7 @@ def run(
             summary_elapsed_seconds=(
                 rejected_discovery.duration_seconds if rejected_discovery is not None else None
             ),
-            discovery_summary=(
-                _discovery_summary(rejected_discovery) if rejected_discovery is not None else None
-            ),
+            discovery_summary=discovery_summary,
         )
         if result.ok:
             return 0

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime/runtime.py

@@ -1605,6 +1605,19 @@ class Runtime:
                 failures.append((project.root, str(exc)))
         return AdoptionBatchResult(selected_plan, tuple(results), tuple(failures))
 
+    def write_agents_guide(self, root: str | os.PathLike[str]) -> Path | None:
+        """Write the default AGENTS.md into a project root.
+
+        Returns the created path, or ``None`` when a guide already exists —
+        an existing guide is the project's own voice and is never replaced.
+        """
+        target = Path(root).expanduser().resolve()
+        guide = target / "AGENTS.md"
+        if guide.exists():
+            return None
+        guide.write_text(_DEFAULT_AGENTS_GUIDE, encoding="utf-8")
+        return guide
+
     def scan_projects(
         self, path: str | os.PathLike[str], *, recursive: bool = True
     ) -> ProjectScanResult:

{lean_runtime-4.22.0 → lean_runtime-4.23.0/lean_runtime.egg-info}/PKG-INFO

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

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/lean_runtime.egg-info/SOURCES.txt

@@ -167,6 +167,7 @@ tests/test_packs.py
 tests/test_paths.py
 tests/test_prebuilt_policy.py
 tests/test_programs.py
+tests/test_project_bootstrap.py
 tests/test_project_publish.py
 tests/test_projects.py
 tests/test_references.py

{lean_runtime-4.22.0 → lean_runtime-4.23.0}/pyproject.toml

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