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

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

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 4.24.0 - 2026-08-26
+
+- Key shared Lake package artifacts by the exact installed Lean and Lake
+  executable digests. Existing `/1` package artifacts are source-only donors;
+  the first build of each project re-shares artifacts under the `/2` key.
+- Let an exact registered dependency graph donate source across toolchain
+  versions, while stripping its build tree, and refresh existing project
+  attachments when their computed workspace identity changes.
+- Report obsolete `/1` project artifacts in `doctor`, reclaim them through
+  `clean`, and refuse publishing moving toolchain spellings such as `master`
+  or undated `nightly`. Publication also fails early when its input is an
+  acquired sparse capsule rather than a source build.
+
 ## 4.23.0 - 2026-08-24
 
 ## 4.22.0 - 2026-08-23

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

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

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

@@ -179,6 +179,7 @@ def _render_cleanup(
     environments: CleanupReport,
     downloads: DownloadCleanupReport | None,
     scratch: CleanupReport | None = None,
+    project_artifacts: CleanupReport | None = None,
 ) -> None:
     style = styler_for(sys.stdout)
     retained_note = style.dim(
@@ -220,6 +221,17 @@ def _render_cleanup(
                 )
             else:
                 print("No abandoned workspaces to remove.")
+        if project_artifacts is not None:
+            if project_artifacts.candidates:
+                anything = True
+                print(
+                    style.bold(
+                        f"Would remove {len(project_artifacts.candidates)} obsolete project "
+                        f"artifact tree(s) · {format_byte_size(project_artifacts.candidate_bytes)}"
+                    )
+                )
+            else:
+                print("No obsolete /1 project artifacts to remove.")
         print(retained_note)
         if anything:
             print()
@@ -228,10 +240,13 @@ def _render_cleanup(
     reclaimed = environments.reclaimed_bytes + (downloads.reclaimed_bytes if downloads else 0)
     if scratch is not None:
         reclaimed += scratch.reclaimed_bytes
+    if project_artifacts is not None:
+        reclaimed += project_artifacts.reclaimed_bytes
     removed = (
         len(environments.removed)
         + (len(downloads.removed) if downloads else 0)
         + (len(scratch.removed) if scratch else 0)
+        + (len(project_artifacts.removed) if project_artifacts else 0)
     )
     if removed:
         parts = [f"{len(environments.removed)} environment(s)"]
@@ -239,6 +254,8 @@ def _render_cleanup(
             parts.append(f"{len(downloads.removed)} cached download(s)")
         if scratch is not None:
             parts.append(f"{len(scratch.removed)} abandoned workspace(s)")
+        if project_artifacts is not None:
+            parts.append(f"{len(project_artifacts.removed)} obsolete project artifact tree(s)")
         print(
             style.green(f"Removed {' and '.join(parts)} · reclaimed {format_byte_size(reclaimed)}")
         )
@@ -2460,12 +2477,19 @@ def main(argv: list[str] | None = None) -> int:
                 dry_run=True,
                 minimum_age_seconds=min(args.minimum_age_hours * 3600, 3600),
             )
+            preview_project_artifacts = runtime.clean_legacy_project_artifacts(dry_run=True)
             if not args.json:
-                _render_cleanup(cleanup_preview, preview_downloads, preview_scratch)
+                _render_cleanup(
+                    cleanup_preview,
+                    preview_downloads,
+                    preview_scratch,
+                    preview_project_artifacts,
+                )
             has_candidates = bool(
                 cleanup_preview.candidates
                 or (preview_downloads and preview_downloads.candidates)
                 or preview_scratch.candidates
+                or preview_project_artifacts.candidates
             )
             if has_candidates and not args.dry_run:
                 execute_cleanup = _confirm("Remove these files?", yes=args.yes, json_mode=args.json)
@@ -2486,11 +2510,15 @@ def main(argv: list[str] | None = None) -> int:
                 dry_run=not execute_cleanup,
                 minimum_age_seconds=min(args.minimum_age_hours * 3600, 3600),
             )
+            gc_project_artifacts = runtime.clean_legacy_project_artifacts(
+                dry_run=not execute_cleanup
+            )
             if args.json:
                 gc_payload: dict[str, Any] = {
                     "environments": gc_report.to_dict(),
                     "downloaded_files": gc_downloads.to_dict() if gc_downloads else None,
                     "scratch": gc_scratch.to_dict(),
+                    "project_artifacts": gc_project_artifacts.to_dict(),
                 }
                 _json(
                     envelope(
@@ -2500,7 +2528,7 @@ def main(argv: list[str] | None = None) -> int:
                     )
                 )
             elif execute_cleanup:
-                _render_cleanup(gc_report, gc_downloads, gc_scratch)
+                _render_cleanup(gc_report, gc_downloads, gc_scratch, gc_project_artifacts)
             return 0
         if args.command == "check":
             if args.across is not None:

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/environments.py

@@ -766,7 +766,11 @@ class Environment:
                 spawn(
                     resolved_command,
                     cwd=instance,
-                    environment=self.manager.toolchains.environment,
+                    environment=(
+                        self.manager.toolchains.environment_for(self.lock.toolchain)
+                        if requested_command[0] == "lake"
+                        else self.manager.toolchains.environment
+                    ),
                     policy=selected_policy,
                 ),
             )
@@ -905,7 +909,12 @@ class Environment:
                 preliminary: list[BackendResult] = []
                 path_map = {str(instance / name): name for name in files}
                 staging_started = time.monotonic()
-                execution_environment = self.manager.toolchains.environment
+                execution_environment = (
+                    self.manager.toolchains.environment_for(self.lock.toolchain)
+                    if operation == "build"
+                    or (requested_command and requested_command[0] == "lake")
+                    else self.manager.toolchains.environment
+                )
                 if operation == "check":
                     assert entrypoint is not None
                     for name, source in files.items():
@@ -1301,7 +1310,11 @@ class EnvironmentManager:
                 result = self.backend.execute(
                     command,
                     cwd=workspace,
-                    environment=self.toolchains.environment,
+                    environment=(
+                        self.toolchains.environment_for(lock.toolchain)
+                        if requested_command[0] == "lake"
+                        else self.toolchains.environment
+                    ),
                     policy=build_policy,
                     cancel=cancel,
                 )
@@ -1327,7 +1340,7 @@ class EnvironmentManager:
                 result = self.backend.execute(
                     command,
                     cwd=workspace,
-                    environment=self.toolchains.environment,
+                    environment=self.toolchains.environment_for(lock.toolchain),
                     policy=build_policy,
                     cancel=cancel,
                 )

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/health.py

@@ -107,6 +107,20 @@ def diagnose(toolchains: ToolchainManager, store: EnvironmentStore) -> DoctorRep
         )
     else:
         checks.append(DoctorCheck("scratch", "pass", "No abandoned workspaces"))
+    legacy_artifacts = store.clean_legacy_project_artifacts(dry_run=True)
+    if legacy_artifacts.candidates:
+        checks.append(
+            DoctorCheck(
+                "project-artifacts-v1",
+                "warning",
+                f"{len(legacy_artifacts.candidates)} package artifact tree(s) use the obsolete "
+                "toolchain-insensitive /1 key; reclaim them with `lean-runtime clean --yes`",
+            )
+        )
+    else:
+        checks.append(
+            DoctorCheck("project-artifacts-v1", "pass", "No obsolete /1 project artifacts")
+        )
     store_status = store.status()
     cutoff = datetime.now(timezone.utc).timestamp() - STALE_ENVIRONMENT_AGE_HOURS * 3600
     stale = tuple(
@@ -145,6 +159,7 @@ def repair(toolchains: ToolchainManager, store: EnvironmentStore) -> DoctorRepor
         include_legacy=True,
         legacy_minimum_age_seconds=LEGACY_SCRATCH_MINIMUM_AGE_SECONDS,
     )
+    store.clean_legacy_project_artifacts(dry_run=False)
     with suppress(ToolchainError):
         toolchains.elan_path(bootstrap=True)
     return diagnose(toolchains, store)

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/lake_cache.py

@@ -160,7 +160,7 @@ class LakeArtifactCache:
         try:
             process = subprocess.run(
                 self.toolchains.command(toolchain, "lake", *arguments),
-                env=self.toolchains.environment,
+                env=self.toolchains.environment_for(toolchain),
                 text=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
@@ -183,7 +183,7 @@ class LakeArtifactCache:
 
     def environment(self, context: ProjectContext) -> dict[str, str]:
         """Return root-only cache settings without caching dependency packages."""
-        environment = self.toolchains.environment
+        environment = self.toolchains.environment_for(context.toolchain)
         if not self.project_opted_in(context):
             return environment
         self.capabilities(context.toolchain)

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

@@ -28,7 +28,7 @@ from .bundles import (
     EnvironmentBundles,
     _capsule_config_object,
 )
-from .capsules import CapsuleManifest
+from .capsules import CAPSULE_MANIFEST, CapsuleManifest
 from .errors import (
     CredentialAcquisitionError,
     DownloadLimitExceeded,
@@ -62,6 +62,7 @@ from .store import (
     platform_compatibility,
     platform_record,
 )
+from .toolchains import immutable_toolchain_spelling
 
 _REPOSITORY = re.compile(r"[a-z0-9]+(?:[._-][a-z0-9]+)*(?:/[a-z0-9]+(?:[._-][a-z0-9]+)*)+")
 _BEARER_PARAMETER = re.compile(r'([a-zA-Z]+)="([^"]*)"')
@@ -1458,6 +1459,22 @@ class OCIEnvironmentPublisher:
     ) -> PublicationInfo:
         if profile != "check-capsule":
             raise ValueError("publication profile must be 'check-capsule'")
+        root = self.store.environment_path(environment_id)
+        try:
+            metadata = json.loads((root / "metadata.json").read_text(encoding="utf-8"))
+            lock = self.store.load_lock(str(metadata["lock_id"]))
+        except (OSError, KeyError, TypeError, json.JSONDecodeError) as exc:
+            raise EnvironmentError("publication input has invalid environment metadata") from exc
+        if (root / "workspace" / CAPSULE_MANIFEST).is_file():
+            raise EnvironmentError(
+                "publication input must be source-built; sparse acquired capsules cannot be "
+                "republished"
+            )
+        if not immutable_toolchain_spelling(lock.toolchain):
+            raise EnvironmentError(
+                f"refusing to publish mutable toolchain spelling {lock.toolchain!r}; "
+                "use an immutable release or dated nightly"
+            )
         self.check_access()
         with tempfile.TemporaryDirectory(prefix="lean-runtime-publish-") as temporary:
             temporary_root = Path(temporary)

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

@@ -214,6 +214,7 @@ class ProjectExecutor:
                 project=provenance,
                 packages=context.package_provenance(),
                 logical_command=("lake", "env", "lean", relative),
+                environment=self.runtime.toolchains.environment_for(context.toolchain),
                 cancel=cancel,
             )
 
@@ -260,6 +261,7 @@ class ProjectExecutor:
                     packages=context.package_provenance(),
                     logical_command=("lake", "env", "lean", safe_filename),
                     path_map={relative: safe_filename, str(source_path): safe_filename},
+                    environment=self.runtime.toolchains.environment_for(context.toolchain),
                     cancel=cancel,
                 )
 
@@ -349,6 +351,10 @@ class ProjectExecutor:
         shared: bool | None = None,
         restore_artifacts: bool = False,
     ) -> ExecutionResult:
+        # Shared preparation may select compiled donors before Lake is invoked.
+        # Establish the exact full build toolchain first so the entire operation,
+        # including nested Lake/Lean subprocesses, has one toolchain boundary.
+        self.runtime.toolchains.ensure_full(context.toolchain, cancel=cancel)
         selected_shared = project_sharing_enabled(context.root) if shared is None else shared
         workspace = (
             self.runtime.shared_projects.prepare(context, cancel=cancel)
@@ -501,7 +507,7 @@ class ProjectExecutor:
             process = subprocess.run(
                 command,
                 cwd=context.root,
-                env=self.runtime.toolchains.environment,
+                env=self.runtime.toolchains.environment_for(context.toolchain),
                 text=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/project_sharing.py

@@ -465,6 +465,7 @@ def plan_adoption(
                     entry=entry,
                     source_package=source_package,
                     effective_entries=effective_entries,
+                    toolchain_identity=None,
                 )
                 key = sha256_id("project_package", identity)
             else:
@@ -558,6 +559,41 @@ class ProjectAdopter:
         lake_dir = context.root / ".lake"
         lake_dir.mkdir(parents=True, exist_ok=True)
         packages_dir = _packages_directory(context)
+        marker = lake_dir / ATTACHMENT_RECORD
+        try:
+            attachment = json.loads(marker.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            attachment = None
+        links_match = isinstance(attachment, dict) and (
+            attachment.get("schema") == ATTACHMENT_SCHEMA
+            and attachment.get("workspace_id") == workspace.workspace_id
+        )
+        if links_match:
+            for entry in manifest_packages:
+                if entry["type"] != "git":
+                    continue
+                name = str(entry["name"])
+                package_dir = override_package_dirs.get(name)
+                link = packages_dir / name
+                if package_dir is None or not link.is_symlink():
+                    links_match = False
+                    break
+                subdir = _package_subdir(entry)
+                target = package_dir
+                if subdir is not None:
+                    for _part in subdir.parts:
+                        target = target.parent
+                if link.resolve() != target.resolve():
+                    links_match = False
+                    break
+        if links_match:
+            return AdoptionResult(
+                context.root,
+                "already-attached",
+                len(workspace.package_ids),
+                0,
+                workspace.workspace_id,
+            )
         if packages_dir.parent != lake_dir:
             packages_dir.parent.mkdir(parents=True, exist_ok=True)
         token = f"{os.getpid()}.{uuid.uuid4().hex}"
@@ -567,7 +603,6 @@ class ProjectAdopter:
         staging.mkdir()
         swapped = False
         had_original = packages_dir.exists() or packages_dir.is_symlink()
-        marker = lake_dir / ATTACHMENT_RECORD
         config = context.root / PROJECT_CONFIG
         try:
             self.shared.events.emit(

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/projects.py

@@ -101,7 +101,7 @@ def _lake_metadata(path: Path, toolchain: str, runtime: Runtime) -> tuple[str, t
             process = subprocess.run(
                 command,
                 cwd=path,
-                env=runtime.toolchains.environment,
+                env=runtime.toolchains.environment_for(toolchain),
                 text=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/references.py

@@ -218,7 +218,7 @@ def _lake_metadata(
         process = subprocess.run(
             command,
             cwd=checkout,
-            env=toolchains.environment,
+            env=toolchains.environment_for(toolchain),
             text=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,

{lean_runtime-4.23.0 → lean_runtime-4.24.0}/lean_runtime/resolver.py

@@ -127,7 +127,7 @@ class EnvironmentResolver:
             process = self.backend.execute(
                 command,
                 cwd=workspace,
-                environment=self.toolchains.environment,
+                environment=self.toolchains.environment_for(toolchain),
                 policy=ExecutionPolicy(timeout_seconds=timeout, max_output_bytes=10_000_000),
                 cancel=cancel,
             )

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

@@ -118,7 +118,7 @@ from .store import (
     platform_record,
 )
 from .toolchain_oci import OCIToolchainLibrary, OCIToolchainPublisher, ToolchainPublication
-from .toolchains import ToolchainManager, normalize_toolchain
+from .toolchains import ToolchainManager, immutable_toolchain_spelling, normalize_toolchain
 from .verification import (
     VerificationCheck,
     VerificationReport,
@@ -254,7 +254,7 @@ class Runtime:
         self.home = self.toolchains.home
         self.backend = backend or LocalBackend()
         self.store = EnvironmentStore(self.home)
-        self.shared_projects = SharedProjectManager(self.home, self.events)
+        self.shared_projects = SharedProjectManager(self.home, self.events, self.toolchains)
         self.lake_cache = LakeArtifactCache(self.home, self.toolchains, self.events)
         self.header_cache = LeanHeaderCache(self.home, self.toolchains, self.events)
         self.identifier_resolver = IdentifierResolver(self.home)
@@ -800,6 +800,16 @@ class Runtime:
         if sign and not finalize:
             raise ValueError("platform-only publishing cannot sign a lock index")
         environment = self.environment(identifier)
+        if environment.sparse:
+            raise EnvironmentError(
+                "publication input must be source-built; sparse acquired capsules cannot be "
+                "republished"
+            )
+        if not immutable_toolchain_spelling(environment.lock.toolchain):
+            raise EnvironmentError(
+                f"refusing to publish mutable toolchain spelling "
+                f"{environment.lock.toolchain!r}; use an immutable release or dated nightly"
+            )
         repository = OCIRepository.parse(library)
         selected_publisher = publisher or OCIEnvironmentPublisher(
             repository, self.store, self.bundles, self.events
@@ -1531,7 +1541,7 @@ class Runtime:
             process = subprocess.run(
                 command,
                 cwd=context.root,
-                env=self.toolchains.environment,
+                env=self.toolchains.environment_for(context.toolchain),
                 text=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
@@ -1569,18 +1579,6 @@ class Runtime:
         results: list[AdoptionResult] = []
         failures: list[tuple[Path, str]] = []
         for project in selected_plan.projects:
-            if project.attached:
-                workspace_id = discover_project(project.root).provenance().workspace_id
-                results.append(
-                    AdoptionResult(
-                        project.root,
-                        "already-attached",
-                        len(project.packages),
-                        0,
-                        workspace_id,
-                    )
-                )
-                continue
             if not project.ready:
                 continue
             context = discover_project(project.root)
@@ -2210,12 +2208,7 @@ class Runtime:
                 plan.project_name or target.name,
                 "lib",
             )
-            environment_for = getattr(self.toolchains, "environment_for", None)
-            command_environment = (
-                environment_for(plan.toolchain)
-                if callable(environment_for)
-                else self.toolchains.environment
-            )
+            command_environment = self.toolchains.environment_for(plan.toolchain)
             process = subprocess.run(
                 command,
                 cwd=staging,
@@ -2472,6 +2465,14 @@ class Runtime:
         """Reclaim abandoned disposable execution and resolution workspaces."""
         return self.store.clean_scratch(dry_run=dry_run, minimum_age_seconds=minimum_age_seconds)
 
+    def clean_legacy_project_artifacts(
+        self, *, dry_run: bool = True, minimum_age_seconds: float = 0
+    ) -> CleanupReport:
+        return self.store.clean_legacy_project_artifacts(
+            dry_run=dry_run,
+            minimum_age_seconds=minimum_age_seconds,
+        )
+
     def clean_downloads(
         self, *, dry_run: bool = True, minimum_age_seconds: float = 2_592_000
     ) -> DownloadCleanupReport:
@@ -2576,6 +2577,9 @@ class Runtime:
                 source_digest=sha256_text(source),
                 policy=policy,
                 path_map={str(source_path): safe_filename},
+                environment=(
+                    self.toolchains.environment_for(selected) if project_root is not None else None
+                ),
                 cancel=cancel,
             )