lean-runtime 2.6.2__tar.gz → 2.7.0__tar.gz

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 2.7.0 - 2026-08-14
+
+- Keep newly initialized project roots narrow: the generated root imports its
+  local `Basic` module without redundantly importing the all-Mathlib umbrella,
+  and the completion hint points to the fast first-file check.
+- Render stdin diagnostics as `<stdin>` in the CLI instead of exposing the
+  disposable `.lake/lean-runtime` staging path.
+- Add fileless `lean-runtime check` and `ProjectEnvironment.check_all()` to
+  check every declared local library through Lake's `leanArts` facets, retaining
+  correct intra-project dependency ordering without building executables.
+- Integrate an ABI- and toolchain-isolated root-project Lake artifact cache for
+  projects created by `init`. Capability support is probed and persisted rather
+  than version-gated; dependencies remain in the verified shared workspace.
+- Keep remote Lake mappings fail-closed until artifacts have a verified SHA-256
+  inventory and lazy restoration participates in acquisition planning and
+  download limits.
+
 ## 2.6.2 - 2026-08-14
 
 - Keep an existing initialization target's directory inode alive, so running

{lean_runtime-2.6.2/lean_runtime.egg-info → lean_runtime-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.6.2
+Version: 2.7.0
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0
@@ -188,6 +188,8 @@ default, and exact dependencies are shared automatically:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+# Check every declared local library, in Lake dependency order:
+lean-runtime check
 lean-runtime build
 ```
 

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/README.md

@@ -152,6 +152,8 @@ default, and exact dependencies are shared automatically:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+# Check every declared local library, in Lake dependency order:
+lean-runtime check
 lean-runtime build
 ```
 

lean_runtime-2.7.0/compatibility/README.md

@@ -0,0 +1,14 @@
+# Compatibility profiles
+
+Profiles exercise published environments rather than mocking Lake. The Mathlib
+4.32.2 and 4.33.0 profiles independently acquire their bundled exact catalog
+locks and import the public `Mathlib` root. Transitive packages remain attested
+in the lock but are not advertised as independent catalog roots.
+
+```bash
+python scripts/run_compatibility.py compatibility/mathlib-4.32.2.json
+python scripts/run_compatibility.py compatibility/mathlib-4.33.0.json
+```
+
+The first run downloads the verified sparse environment. Later runs reuse its
+content-addressed artifacts and published workspace.

lean_runtime-2.7.0/compatibility/lake-artifact-cache-4.33.0.json

@@ -0,0 +1,32 @@
+{
+  "schema": "lean-runtime.lake-cache-contract/v1",
+  "toolchain": "leanprover/lean4:v4.33.0",
+  "lake_version_observed": "5.0.0-src+d8b1897",
+  "capability_probes": {
+    "build_mappings": ["lake", "build", "--help"],
+    "cache_add": ["lake", "cache", "add", "--help"]
+  },
+  "configuration": {
+    "cache_root": "LAKE_CACHE_DIR",
+    "workspace_cache": "LAKE_ARTIFACT_CACHE",
+    "restore": "LAKE_RESTORE_ARTIFACTS",
+    "root_package_opt_in": "enableArtifactCache = true"
+  },
+  "observable_hit_signals": [
+    "found artifact in cache",
+    "restored artifact from cache",
+    "downloaded artifact"
+  ],
+  "experiment": {
+    "broad_cache_bytes": 6500000000,
+    "explicit_library_jobs": 8708,
+    "root_only_cache_bytes": 396000,
+    "root_restore_seconds": 5.17,
+    "dependency_heavy_fixture": "mathlib consumer",
+    "focused_lake_env_lean_uses_artifact_cache": false
+  },
+  "security": {
+    "lake_remote_hash_cryptographic": false,
+    "remote_registration": "disabled_pending_attested_sha256_inventory"
+  }
+}

lean_runtime-2.7.0/compatibility/mathlib-4.32.2.json

@@ -0,0 +1,8 @@
+{
+  "name": "mathlib-4.32.2",
+  "reference": "mathlib@v4.32.2",
+  "spec": "mathlib-4.32.2.toml",
+  "imports": [
+    "Mathlib"
+  ]
+}

lean_runtime-2.7.0/compatibility/mathlib-4.33.0.json

@@ -0,0 +1,8 @@
+{
+  "name": "mathlib-4.33.0",
+  "reference": "mathlib@v4.33.0",
+  "spec": "mathlib-4.33.0.toml",
+  "imports": [
+    "Mathlib"
+  ]
+}

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/docs/architecture.md

@@ -39,6 +39,22 @@ published environment identity includes platform and build-profile inputs.
 Each execution attempt has a unique history identity. A separate stable request
 digest includes the environment, input digest, operation, and requested policy.
 
+## Internal ownership
+
+The high-level `Runtime` is a compatibility facade rather than the owner of
+every workflow. Environment resolution and materialization remain in their
+dedicated managers. Mutable local-project checks and builds pass through
+`ProjectExecutor`, which owns Lake command selection and shared-workspace build
+locking. This is the integration boundary for Lake facilities such as its
+artifact cache; `Runtime` should not grow a second project build planner.
+
+Environment capsules, slim toolchains, and ready-to-run programs have distinct
+payload schemas. Their common OCI descriptor, digest, JSON, and platform
+selection contract lives in `oci_protocol`. Payload implementations must not
+import another payload implementation's private protocol helpers. Existing
+legacy bundle readers remain supported, but new transport behavior belongs to
+the shared protocol or the current sparse capsule path.
+
 ## Public identities
 
 Two lifecycle identities are central to the ordinary API:

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/docs/getting-started.md

@@ -21,12 +21,15 @@ shared exact dependencies:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check
 lean-runtime build
 ```
 
 By default, `init` writes an `AGENTS.md` explaining the project workflow and
 shared-dependency safety rules to coding agents. Pass `--no-agents` to omit it.
-An existing file is preserved.
+An existing file is preserved. The generated root imports only the project's
+local `Basic` module; add the narrow Mathlib imports each implementation file
+needs rather than paying for the all-Mathlib umbrella on every root import.
 
 Use `--mathlib 4.33.0` to select that release explicitly, or `--core` for a
 core-only library. The root project remains an ordinary mutable Lake project;

lean_runtime-2.7.0/docs/lake-artifact-cache-design.md

@@ -0,0 +1,154 @@
+# Lake artifact-cache integration design
+
+!!! note
+
+    The root-only local cache and project-wide check described below are
+    implemented. Remote mappings remain deliberately gated on strong artifact
+    verification and acquisition planning.
+
+## Ownership
+
+Lean Runtime should complement the standard Lean tools rather than replace
+their build semantics:
+
+- Elan selects and installs the toolchain pinned by `lean-toolchain`.
+- Lake resolves packages and owns targets, facets, traces, executables, custom
+  build logic, and complete project builds.
+- Mathlib's cache supplies prebuilt upstream artifacts but does not cache a
+  downstream project's own outputs.
+- Lake's artifact cache shares input- and content-addressed outputs between
+  workspaces using the same toolchain and can register remote mappings for lazy
+  restoration.
+- Lean Runtime selects, verifies, distributes, and shares an exact environment
+  with provenance and download policy.
+
+Consequently, Lean Runtime must not implement a second general-purpose Lake
+target scheduler.
+
+## Public contract
+
+The intended commands are:
+
+```text
+lean-runtime check Foo.lean
+lean-runtime check
+lean-runtime build
+```
+
+`check Foo.lean` remains the focused development loop. A file-less `check`
+will check all local Lean modules without producing executables or native
+libraries. `build` remains a complete Lake-compatible build of declared local
+targets; it must not silently become a partial build.
+
+## Integration boundary
+
+`ProjectExecutor` owns project command selection and execution policy. A future
+`LakeArtifactCache` service should be injected into that executor and should
+own only cache location, mappings, and restoration:
+
+```text
+published OCI environment
+  ├── exact source and lock provenance
+  ├── sparse check capsule
+  └── Lake input-to-output mappings
+                 │
+                 ▼
+toolchain-scoped Lake artifact cache
+                 │
+                 ▼
+ProjectExecutor ─────► ordinary Lake target graph
+```
+
+The cache directory must be keyed by the exact Lean toolchain identity and
+platform ABI. It must never mix artifacts across incompatible toolchains.
+
+## Lake 4.33 experiment and decision
+
+The experiment used one generated Mathlib 4.33 project and preserved the same
+source and shared dependency graph for every measurement. The exact observed
+interface is checked into `compatibility/lake-artifact-cache-4.33.0.json`.
+
+Compare:
+
+1. the current bare Lake build through `lean-runtime build`;
+2. explicit root-package, local-library, root-module `leanArts`, and executable
+   targets;
+3. the same targets with `LAKE_ARTIFACT_CACHE=true` and a toolchain-scoped
+   `LAKE_CACHE_DIR`;
+4. the cache with publication mappings captured by `lake build -o` and
+   registered locally;
+5. warm process-cache and cold filesystem-cache runs.
+
+The broad workspace cache was rejected: it copied about 6.5 GB of dependency
+artifacts into a second cache and an explicit `@/Library:leanArts` target still
+traversed 8,708 jobs. A root package with `enableArtifactCache = true`, combined
+with workspace-level `LAKE_ARTIFACT_CACHE=false`, cached only root artifacts
+(about 396 KB in the fixture) and restored them in about five seconds. This is
+the implemented mode.
+
+Support is detected from command behavior and help surfaces, not a parsed Lake
+version. The verdict is cached by exact toolchain identity and platform ABI.
+Verbose Lake output provides deterministic hit markers such as `restored
+artifact from cache`; timing alone is not treated as proof of a hit.
+
+## Publication and acquisition
+
+When the remaining integrity and performance gates succeed, environment publication should run the ordinary
+verified build with a Lake mappings output. Publication should bind the mapping
+digest to the same exact source revision, complete Lake graph, toolchain, and
+platform record as the capsule.
+
+Acquisition should:
+
+1. verify the environment and mapping descriptors through the existing OCI
+   trust path;
+2. install compatible artifacts into the toolchain-scoped Lake cache or add
+   mappings that point to a configured remote service;
+3. leave Lake responsible for evaluating input traces and restoring outputs;
+4. fail explicitly on corrupt mappings or artifacts instead of silently
+   treating them as verified environment content;
+5. permit an ordinary source build when policy allows it.
+
+Lake recomputes its artifact hash after a remote fetch, but that hash is not a
+cryptographic integrity boundary. Lean Runtime therefore does not currently
+register remote mappings. A future remote adapter must bind a SHA-256 artifact
+inventory into the verified OCI record, verify every restored artifact, emit
+`acquisition.planned`, and charge all bytes against `max_download_bytes` before
+registration. Until then, remote object storage would be inside the trust
+boundary and is rejected.
+
+OCI remains the environment and provenance distribution format. Lake's cache
+format remains the build-cache contract. Translation between them belongs in a
+small adapter, not in capsule, registry, or project CLI code.
+
+## Performance gate
+
+The slice ships only if the same empty Mathlib project satisfies:
+
+| Journey | Budget |
+| --- | ---: |
+| Focused warm file check | at most 3 seconds |
+| Project-wide check | at most 10 seconds |
+| First build with shared cache ready | at most 10 seconds |
+| Warm no-op build | at most 3 seconds |
+| Executable build | comparable to native Lake |
+| Custom facet | handled unchanged by Lake |
+
+Correctness gates must include libraries, executables, multiple local modules,
+custom Lean options, Mathlib plus LeanCert, a supported custom facet, an
+unsupported cache entry, corrupted cache content, and concurrent projects using
+the same cache.
+
+The scheduled compatibility workflow runs the root-cache correctness and
+timing gate on macOS ARM and Linux x86. It verifies a first check, a warm check,
+and restoration after removing the checkout-local build directory. Ordinary CI
+also exercises toolchain/ABI key separation on both platforms. The cache does
+not participate in the focused `lake env lean` path; that path consumes already
+available imports directly.
+
+Explicit targets and the native cache did not remove dependency-graph
+traversal. The implemented fileless `check` therefore asks Lake to build only
+local library `leanArts` facets, preserving correct intra-project ordering. The
+next performance step is an opaque-prebuilt-dependency optimization in Lake.
+A specialized local-module scheduler remains a last resort and would be called
+`check`, never `build`.

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/docs/local-projects.md

@@ -46,12 +46,29 @@ each repository's `.lake/packages`. New projects can start in shared mode:
 lean-runtime init MyProof
 cd MyProof
 lean-runtime check MyProof/Basic.lean
+lean-runtime check
 lean-runtime build
 ```
 
+The fileless form asks Lake for the project's declared local libraries and
+builds their `leanArts` facets. Lake therefore expands roots and submodules,
+orders local imports, and creates any intermediate local `.olean` files; Lean
+Runtime does not parse module globs or implement a second build scheduler. It
+does not request executable or native-library targets. The Python equivalent is
+`Runtime().project(".").check_all()`.
+
+Projects created by `init` on a supported Lake also opt their root package into
+Lake's native artifact cache. Lean Runtime capability-probes the resolved Lake executable
+once, stores the result per exact toolchain and platform ABI, and otherwise
+stays silent. Only root-project outputs enter this cache: locked dependencies
+continue to use the verified shared workspace, avoiding a second multi-gigabyte
+copy. `build` retains Lake's complete target semantics.
+
 The generated files are a standard Lake project plus a small
 `lean-runtime.toml`. Root build outputs stay local; exact dependencies are
-shared. The newest stable cataloged Mathlib is selected by default. Select a
+shared. The generated root imports only its local `Basic` module, leaving
+implementation files free to select precise Mathlib modules. The newest stable
+cataloged Mathlib is selected by default. Select a
 release with `--mathlib 4.33.0`, or use `--core` for a core-only library.
 `init` also creates an `AGENTS.md` describing the safe
 build and dependency workflow unless `--no-agents` is passed; it never

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/lean_runtime/bundles.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import gzip
 import hashlib
 import io
-import json
 import os
 import re
 import shutil
@@ -38,6 +37,22 @@ from .events import EventEmitter
 from .lake import ROOT_MODULE
 from .lockfiles import EnvironmentLock, LockedPackage
 from .locking import FileLock
+from .oci_protocol import (
+    INDEX_MEDIA_TYPE,
+    MANIFEST_MEDIA_TYPE,
+)
+from .oci_protocol import (
+    blob_descriptor_path as _blob_descriptor_path,
+)
+from .oci_protocol import (
+    descriptor_blob_path as _descriptor_blob_path,
+)
+from .oci_protocol import (
+    json_object as _json_object,
+)
+from .oci_protocol import (
+    require_media_type as _require_media_type,
+)
 from .packs import (
     PACK_MEDIA_TYPE,
     SparsePack,
@@ -60,8 +75,6 @@ CAPSULE_BUNDLE_SCHEMA = "lean-runtime-oci-capsule/1"
 CONFIG_MEDIA_TYPE = "application/vnd.lean-runtime.environment.config.v1+json"
 CAPSULE_CONFIG_MEDIA_TYPE = "application/vnd.lean-runtime.capsule.config.v1+json+zstd"
 LAYER_MEDIA_TYPE = "application/vnd.lean-runtime.environment.layer.v1.tar+gzip"
-MANIFEST_MEDIA_TYPE = "application/vnd.oci.image.manifest.v1+json"
-INDEX_MEDIA_TYPE = "application/vnd.oci.image.index.v1+json"
 MAX_BUNDLE_BYTES = 20 * 1024**3
 MAX_FILES = 2_000_000
 SOURCE_TREE_INVENTORY = ".lean-runtime-source-tree.json"
@@ -84,18 +97,6 @@ class PortableCopyInfo:
         }
 
 
-def _digest(data: bytes) -> str:
-    return "sha256:" + hashlib.sha256(data).hexdigest()
-
-
-def _digest_path(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return "sha256:" + digest.hexdigest()
-
-
 def _capsule_config_bytes(value: Mapping[str, Any]) -> bytes:
     return zstandard.ZstdCompressor(level=10, write_checksum=True).compress(
         canonical_json_bytes(dict(value))
@@ -112,19 +113,6 @@ def _capsule_config_object(data: bytes) -> dict[str, Any]:
     return _json_object(decoded, "capsule config")
 
 
-def _blob_descriptor(data: bytes, media_type: str, **extra: Any) -> dict[str, Any]:
-    return {"mediaType": media_type, "digest": _digest(data), "size": len(data), **extra}
-
-
-def _blob_descriptor_path(path: Path, media_type: str, **extra: Any) -> dict[str, Any]:
-    return {
-        "mediaType": media_type,
-        "digest": _digest_path(path),
-        "size": path.stat().st_size,
-        **extra,
-    }
-
-
 def _normalized_info(name: str, *, mode: int, kind: bytes = tarfile.REGTYPE) -> tarfile.TarInfo:
     info = tarfile.TarInfo(name)
     info.type = kind
@@ -245,43 +233,6 @@ def _write_oci_archive(entries: dict[str, Path], output: Path) -> None:
                 archive.addfile(info, handle)
 
 
-def _json_object(data: bytes, label: str) -> dict[str, Any]:
-    try:
-        value = json.loads(data)
-    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
-        raise EnvironmentError(f"bundle {label} is not valid JSON") from exc
-    if not isinstance(value, dict):
-        raise EnvironmentError(f"bundle {label} must be a JSON object")
-    return value
-
-
-def _descriptor_blob(entries: dict[str, bytes], descriptor: dict[str, Any], label: str) -> bytes:
-    digest = descriptor.get("digest")
-    size = descriptor.get("size")
-    if not isinstance(digest, str) or not digest.startswith("sha256:"):
-        raise EnvironmentError(f"bundle {label} has an invalid digest")
-    data = entries.get("blobs/sha256/" + digest.removeprefix("sha256:"))
-    if data is None or len(data) != size or _digest(data) != digest:
-        raise EnvironmentError(f"bundle {label} digest mismatch")
-    return data
-
-
-def _descriptor_blob_path(entries: dict[str, Path], descriptor: dict[str, Any], label: str) -> Path:
-    digest = descriptor.get("digest")
-    size = descriptor.get("size")
-    if not isinstance(digest, str) or not digest.startswith("sha256:"):
-        raise EnvironmentError(f"bundle {label} has an invalid digest")
-    path = entries.get("blobs/sha256/" + digest.removeprefix("sha256:"))
-    if path is None or path.stat().st_size != size or _digest_path(path) != digest:
-        raise EnvironmentError(f"bundle {label} digest mismatch")
-    return path
-
-
-def _require_media_type(descriptor: dict[str, Any], expected: str, label: str) -> None:
-    if descriptor.get("mediaType") != expected:
-        raise EnvironmentError(f"bundle {label} has an unsupported media type")
-
-
 def _safe_name(name: str) -> PurePosixPath:
     path = PurePosixPath(name)
     if (

{lean_runtime-2.6.2 → lean_runtime-2.7.0}/lean_runtime/cli.py

@@ -248,14 +248,32 @@ def _cli_source_name(path: Path) -> str:
     return path.as_posix()
 
 
-def _emit_result(result: ExecutionResult, as_json: bool) -> None:
+def _display_result_text(text: str, result: ExecutionResult, display_path: str | None) -> str:
+    """Rewrite only the staged entrypoint when the CLI has a logical input name."""
+    if display_path is None or not result.command:
+        return text
+    staged = result.command[-1]
+    candidates = {staged}
+    staged_path = Path(staged)
+    if not staged_path.is_absolute():
+        candidates.add(str(Path(result.cwd) / staged_path))
+    for candidate in sorted(candidates, key=len, reverse=True):
+        text = text.replace(candidate, display_path)
+    return text
+
+
+def _emit_result(
+    result: ExecutionResult, as_json: bool, *, display_path: str | None = None
+) -> None:
     if as_json:
         _json(serialize_execution_v1(result))
         return
     if result.stdout:
-        print(result.stdout, end="" if result.stdout.endswith("\n") else "\n")
+        stdout = _display_result_text(result.stdout, result, display_path)
+        print(stdout, end="" if stdout.endswith("\n") else "\n")
     if result.stderr:
-        print(result.stderr, end="" if result.stderr.endswith("\n") else "\n", file=sys.stderr)
+        stderr = _display_result_text(result.stderr, result, display_path)
+        print(stderr, end="" if stderr.endswith("\n") else "\n", file=sys.stderr)
     status = "accepted" if result.ok else "rejected"
     environment = f" environment={result.environment_id}" if result.environment_id else ""
     print(
@@ -435,11 +453,11 @@ def parser() -> argparse.ArgumentParser:
     program_index.add_argument("--tag", action="append", default=[])
     program_index.add_argument("--sign", action="store_true")
 
-    check = commands.add_parser("check", help="check one Lean file in its exact context")
+    check = commands.add_parser("check", help="check one Lean file or all local libraries")
     check.add_argument(
         "inputs",
-        nargs="+",
-        help="FILE, or legacy ENVIRONMENT FILE; FILE may be - for stdin",
+        nargs="*",
+        help="FILE, legacy ENVIRONMENT FILE, or omit inside a Lake project; FILE may be -",
     )
     check.add_argument(
         "--with",
@@ -450,7 +468,9 @@ def parser() -> argparse.ArgumentParser:
         help="repeatable github:owner/repository@tag-or-commit package reference",
     )
     check.add_argument("--toolchain", help="override the discovered file or package toolchain")
-    check.add_argument("--project", type=Path, help="explicit Lake project for FILE")
+    check.add_argument(
+        "--project", type=Path, help="explicit Lake project for FILE or project-wide check"
+    )
     check.add_argument(
         "--include", action="append", default=[], type=Path, help="additional Lean source file"
     )
@@ -656,6 +676,7 @@ def parser() -> argparse.ArgumentParser:
 def main(argv: list[str] | None = None) -> int:
     args = parser().parse_args(argv)
     operation_started = time.monotonic()
+    display_path: str | None = None
     try:
         selected_availability = (
             "local" if args.command in {"init", "update"} and args.offline else args.availability
@@ -712,7 +733,10 @@ def main(argv: list[str] | None = None) -> int:
                 print(f"Shared packages: {init_result.packages}")
                 if args.agents:
                     print(f"Agent guide: {init_result.root / 'AGENTS.md'}")
-                print(f"Next: cd {init_result.root} && lean-runtime build")
+                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"
+                )
             return 0
         if args.command == "scan":
             scan_result = runtime.scan_projects(args.path, recursive=args.recursive)
@@ -859,7 +883,7 @@ def main(argv: list[str] | None = None) -> int:
             print(f"Created {output}")
             return 0
         if args.command == "install":
-            print(runtime.toolchains.ensure(args.toolchain))
+            print(runtime.toolchains.ensure_full(args.toolchain))
             return 0
         if args.command == "prepare":
             lock = runtime.prepare(EnvironmentSpec.load(args.spec), timeout=args.timeout)
@@ -1195,7 +1219,14 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "check":
             if args.project is not None and args.package_refs:
                 raise ValueError("check cannot combine --project with --with")
-            if args.package_refs:
+            if not args.inputs:
+                if args.package_refs or args.include:
+                    raise ValueError("project-wide check does not accept --with or --include")
+                result = runtime.check_project(
+                    args.project or Path("."), toolchain=args.toolchain, policy=_policy(args)
+                )
+                source_file = None
+            elif args.package_refs:
                 if len(args.inputs) != 1:
                     raise ValueError("check with --with expects exactly one FILE")
                 environment = runtime.open_references(args.package_refs, toolchain=args.toolchain)
@@ -1205,6 +1236,7 @@ def main(argv: list[str] | None = None) -> int:
                     raise ValueError("local project checks do not accept --include")
                 source_file = Path(args.inputs[0])
                 if str(source_file) == "-":
+                    display_path = "<stdin>"
                     result = runtime.check(
                         sys.stdin.read(),
                         toolchain=args.toolchain,
@@ -1244,6 +1276,7 @@ def main(argv: list[str] | None = None) -> int:
                 )
         elif args.command == "check-file":
             if str(args.file) == "-":
+                display_path = "<stdin>"
                 result = runtime.check(
                     sys.stdin.read(),
                     toolchain=args.toolchain,
@@ -1300,7 +1333,7 @@ def main(argv: list[str] | None = None) -> int:
         else:
             print(f"lean-runtime: {exc}", file=sys.stderr)
         return 2
-    _emit_result(result, args.json)
+    _emit_result(result, args.json, display_path=display_path)
     if args.timings:
         print(render_timings(result.timings), file=sys.stderr)
     return 0 if result.ok else 1