lean-runtime 2.9.1__tar.gz → 2.10.0__tar.gz

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## Unreleased
 
+## 2.10.0 - 2026-08-16
+
+- Make header snapshots opt-in (`LEAN_RUNTIME_HEADER_SNAPSHOTS=1`; `--watch` and
+  `--repeat` enable them automatically), key them by module identity, load
+  existing snapshots without holding the creation lock, cancel lock waits
+  promptly, and retry once without a snapshot—quarantining it—when a snapshot
+  check times out or reports snapshot errors.
+- Support `check FILE...` and `check DIRECTORY...` with independent per-file
+  results, `--concurrency`, a `lean-runtime.check-batch/v1` JSON envelope, and
+  an explicit `--environment NAME`; the legacy positional `ENVIRONMENT FILE`
+  form now applies only when the first argument is not an existing path.
+- Attribute shared workspace lock waits to their holder (PID and operation),
+  announce header snapshot waits, and record `workspace_lock` and
+  `header_snapshot` phase timings so coordination cost is visible next to the
+  actual Lean check time.
+
+## 2.9.2 - 2026-08-16
+
+- Keep one fail-closed publication authentication session from push preflight through
+  upload, propagate explicit publication timeouts to credential and registry I/O,
+  and report credential-provider failures without labeling them anonymous.
+- Use logical project names during atomic initialization, show compact TTY-only check
+  progress, cache Lean executable identities across invocations, and report check
+  command-preparation timing.
+- Track disposable execution and resolution workspaces with process-held leases;
+  include their footprint in storage reporting and reclaim abandoned workspaces with
+  `clean` while protecting active work.
+
 ## 2.9.1 - 2026-08-15
 
 - Make GHCR credential discovery a single bounded GitHub CLI status read so a

{lean_runtime-2.9.1/lean_runtime.egg-info → lean_runtime-2.10.0}/PKG-INFO

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

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/docs/cli.md

@@ -215,6 +215,9 @@ lean-runtime check research-stack Main.lean --include Support/Defs.lean
 ```
 
 Resolution and materialization print structured lifecycle progress to stderr.
+One-shot checks show a compact in-place status on interactive terminals while Lean
+is working. Redirected output, `--json`, and `--quiet` remain free of human progress;
+`--timings` separates command preparation from Lean execution.
 Pass global `--quiet` before the subcommand to suppress it.
 
 Pass global `--timings` before the subcommand for stable phase timing output. Machine-readable

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/docs/environments.md

@@ -93,6 +93,12 @@ Short-lived execution leases prevent deletion during cloning without
 serializing concurrent checks. Locks and source snapshots remain retained in
 the current store schema.
 
+Disposable execution and dependency-resolution workspaces carry their own
+process-held ownership leases. `storage` includes them under `Scratch`, and
+`clean` previews and reclaims abandoned workspaces while retaining every
+workspace with a live owner. Legacy scratch directories created before ownership
+metadata are removed only by an explicit `clean --execute` after the safety grace.
+
 Sparse downloads are stored once by artifact digest under the shared module
 CAS and hardlinked into environment projections when the filesystem permits.
 `lean-runtime storage` reports this category separately. Because it is shared,

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/docs/local-projects.md

@@ -68,10 +68,19 @@ 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.
 
-Repeated file checks reuse Lean's native header snapshots, keyed by the exact
-toolchain, project identity, and import block. Body-only edits therefore avoid
-reloading the unchanged import environment. `--watch` is a thin save loop over
-the same ordinary check/result contract. Failed checks may add exact-graph
+Repeated checks of one file can reuse Lean's native header snapshots, keyed by
+the exact toolchain, project identity, module, and import block. Body-only
+edits therefore avoid reloading the unchanged import environment. Snapshots are
+used automatically by `--watch` and `--repeat`; set
+`LEAN_RUNTIME_HEADER_SNAPSHOTS=1` to enable them for one-shot checks (or `=0`
+to disable them everywhere). A check that fails or times out under a snapshot
+is retried once without it, and the snapshot is discarded. `--watch` is a thin
+save loop over the same ordinary check/result contract. `check` also accepts
+several files or directories and checks each independently, in parallel with
+`--concurrency`. When one invocation must wait on another, the console names
+the holder (for example `Waiting for shared workspace lock held by PID 512
+(shared build of mathlib)`), and `--timings` reports `workspace_lock` and
+`header_snapshot` phases alongside the actual Lean execution time. Failed checks may add exact-graph
 identifier hints derived from pinned `.ilean` indexes; raw Lean streams remain
 unchanged.
 

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/docs/portable-copies.md

@@ -135,6 +135,12 @@ run:
 gh auth refresh -s write:packages,read:packages
 ```
 
+Credential discovery is fail-closed: a configured provider that times out or
+returns an unusable token stops publication before any registry request. The same
+verified credential is retained from preflight through upload; it is not rediscovered
+after a long environment build. An explicitly supplied publication `--timeout`
+also applies to credential discovery and registry network operations.
+
 Publish the current platform after ensuring the lock:
 
 ```bash

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/lean_runtime/cli.py

@@ -8,12 +8,14 @@ import os
 import re
 import sys
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import replace
 from datetime import datetime
 from importlib.metadata import version as distribution_version
 from pathlib import Path
 from typing import Any, cast
 
-from .console import styler_for
+from .console import ConsoleRenderer, styler_for
 from .environments import ExecutionCapture
 from .errors import (
     LeanRuntimeError,
@@ -23,6 +25,7 @@ from .errors import (
     ResolutionError,
 )
 from .events import RuntimeEvent
+from .header_cache import ENABLE_VARIABLE as _HEADER_SNAPSHOTS_VARIABLE
 from .health import DoctorReport
 from .lake import ROOT_MODULE
 from .lockfiles import EnvironmentLock
@@ -39,6 +42,7 @@ from .timings import render_timings
 from .wire import (
     envelope,
     error,
+    serialize_check_batch_v1,
     serialize_comparison_v1,
     serialize_execution_v1,
     serialize_matrix_v1,
@@ -89,6 +93,7 @@ def _render_storage(status: StoreStatus) -> None:
         ("Project packages", status.project_packages, status.project_packages_bytes),
         ("Toolchains", None, status.toolchains_bytes),
         ("Executions", status.executions, status.executions_bytes),
+        ("Scratch", status.scratch_workspaces, status.scratch_bytes),
     )
     for label, count, bytes_used in rows:
         counted = f"{count:>5}" if count is not None else "     "
@@ -139,7 +144,11 @@ def _render_doctor(report: DoctorReport) -> None:
         print(f"{symbols[check.status]} {check.name}: {check.message}")
 
 
-def _render_cleanup(environments: CleanupReport, downloads: DownloadCleanupReport | None) -> None:
+def _render_cleanup(
+    environments: CleanupReport,
+    downloads: DownloadCleanupReport | None,
+    scratch: CleanupReport | None = None,
+) -> None:
     style = styler_for(sys.stdout)
     retained_note = style.dim(
         f"Retained {len(environments.retained)} environment(s) (named, recent, or in use)."
@@ -169,17 +178,36 @@ def _render_cleanup(environments: CleanupReport, downloads: DownloadCleanupRepor
                 )
             else:
                 print("No unreferenced cached downloads to remove.")
+        if scratch is not None:
+            if scratch.candidates:
+                anything = True
+                print(
+                    style.bold(
+                        f"Would remove {len(scratch.candidates)} abandoned workspace(s) · "
+                        f"{format_byte_size(scratch.candidate_bytes)}"
+                    )
+                )
+            else:
+                print("No abandoned workspaces to remove.")
         print(retained_note)
         if anything:
             print()
             print("This was a preview. Re-run with --execute to delete.")
         return
     reclaimed = environments.reclaimed_bytes + (downloads.reclaimed_bytes if downloads else 0)
-    removed = len(environments.removed) + (len(downloads.removed) if downloads else 0)
+    if scratch is not None:
+        reclaimed += scratch.reclaimed_bytes
+    removed = (
+        len(environments.removed)
+        + (len(downloads.removed) if downloads else 0)
+        + (len(scratch.removed) if scratch else 0)
+    )
     if removed:
         parts = [f"{len(environments.removed)} environment(s)"]
         if downloads is not None:
             parts.append(f"{len(downloads.removed)} cached download(s)")
+        if scratch is not None:
+            parts.append(f"{len(scratch.removed)} abandoned workspace(s)")
         print(
             style.green(f"Removed {' and '.join(parts)} · reclaimed {format_byte_size(reclaimed)}")
         )
@@ -290,11 +318,15 @@ def _print_publication_failure(exc: PublicationError) -> None:
         file=sys.stderr,
     )
     print(f"  {exc}", file=sys.stderr)
-    identity = exc.username or "anonymous"
-    print(
-        f"  Authentication: {identity} (source: {exc.credential_source})",
-        file=sys.stderr,
-    )
+    if exc.attempted_provider is not None:
+        print("  Authentication: unavailable (source: none)", file=sys.stderr)
+        print(f"  Attempted provider: {exc.attempted_provider}", file=sys.stderr)
+    else:
+        identity = exc.username or "anonymous"
+        print(
+            f"  Authentication: {identity} (source: {exc.credential_source})",
+            file=sys.stderr,
+        )
     if exc.partial:
         print(
             "  No verified final release was produced; immutable platform content may exist.",
@@ -314,6 +346,82 @@ def _cli_source_name(path: Path) -> str:
     return path.as_posix()
 
 
+def _expand_check_inputs(inputs: list[str]) -> list[Path]:
+    """Expand FILE and DIRECTORY inputs into an ordered, deduplicated file list."""
+    files: list[Path] = []
+    for raw in inputs:
+        path = Path(raw)
+        if path.is_dir():
+            found: list[Path] = []
+            for current, directories, filenames in os.walk(path):
+                directories[:] = sorted(name for name in directories if not name.startswith("."))
+                found.extend(
+                    Path(current) / name for name in sorted(filenames) if name.endswith(".lean")
+                )
+            if not found:
+                raise ValueError(f"no Lean files found under directory: {path}")
+            files.extend(found)
+        elif path.is_file():
+            files.append(path)
+        else:
+            raise ValueError(f"check input does not exist: {path}")
+    return list(dict.fromkeys(files))
+
+
+def _run_check_batch(runtime: Runtime, files: list[Path], args: argparse.Namespace) -> int:
+    """Check each file independently, optionally in parallel, and report per file."""
+    if args.concurrency < 1 or args.concurrency > 32:
+        raise ValueError("check concurrency must be between 1 and 32")
+    environment = runtime.environment(args.environment) if args.environment else None
+
+    def execute(path: Path) -> ExecutionResult:
+        if environment is not None:
+            name = _cli_source_name(path)
+            return environment.check_files(
+                {name: path.read_text(encoding="utf-8")}, entrypoint=name, policy=_policy(args)
+            )
+        return runtime.check_file(
+            path, toolchain=args.toolchain, project=args.project, policy=_policy(args)
+        )
+
+    started = time.monotonic()
+    results: dict[Path, ExecutionResult] = {}
+    if args.concurrency == 1:
+        for path in files:
+            results[path] = execute(path)
+    else:
+        with ThreadPoolExecutor(
+            max_workers=args.concurrency, thread_name_prefix="lean-check"
+        ) as pool:
+            futures = {pool.submit(execute, path): path for path in files}
+            try:
+                for future in as_completed(futures):
+                    results[futures[future]] = future.result()
+            except BaseException:
+                for future in futures:
+                    future.cancel()
+                raise
+    entries = [(str(path), results[path]) for path in files]
+    runtime.events.emit(
+        "check.completed",
+        "Lean check completed",
+        ok=all(result.ok for _, result in entries),
+    )
+    if args.json:
+        _json(serialize_check_batch_v1(entries, time.monotonic() - started))
+    else:
+        for display, result in entries:
+            status = "accepted" if result.ok else "rejected"
+            print(f"{display}\t{status}\t{result.elapsed_seconds:.2f}s")
+            if not result.ok:
+                output = "\n".join(part for part in (result.stdout, result.stderr) if part).strip()
+                if output:
+                    print(output, file=sys.stderr)
+        accepted = sum(1 for _, result in entries if result.ok)
+        print(f"{accepted}/{len(entries)} accepted")
+    return 0 if all(result.ok for _, result in entries) else 1
+
+
 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:
@@ -436,7 +544,12 @@ Run `lean-runtime COMMAND --help` for examples and options.""",
     publish_environment.add_argument("--publish-to", required=True)
     publish_environment.add_argument("--tag", action="append", default=[])
     publish_environment.add_argument("--name")
-    publish_environment.add_argument("--timeout", type=float, default=1800)
+    publish_environment.add_argument(
+        "--timeout",
+        type=float,
+        default=None,
+        help="override timeouts for credential, registry, hydration, and build operations",
+    )
     publish_environment.add_argument("--platform-only", action="store_true")
     publish_environment.add_argument("--accelerate", action="store_true")
     publish_environment.add_argument("--sign", action="store_true")
@@ -511,8 +624,8 @@ Run `lean-runtime COMMAND --help` for examples and options.""",
     push.add_argument(
         "--timeout",
         type=float,
-        default=1800,
-        help="maximum seconds for each artifact hydration and the environment build",
+        default=None,
+        help="override timeouts for credential, registry, hydration, and build operations",
     )
     push.add_argument(
         "--platform-only",
@@ -623,11 +736,36 @@ Run `lean-runtime COMMAND --help` for examples and options.""",
     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 or all local libraries")
+    check = commands.add_parser(
+        "check",
+        help="check Lean files or all local libraries",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""examples:
+  lean-runtime check                          check every local library of this project
+  lean-runtime check Foo.lean                 check one file in its discovered project
+  lean-runtime check Foo.lean Bar.lean        check several files, one result per file
+  lean-runtime check src --concurrency 4      check every *.lean under src in parallel
+  lean-runtime check Foo.lean --project ~/p   check a file against an explicit Lake project
+  lean-runtime check --environment NAME Foo.lean
+                                              check inside a published environment
+  lean-runtime check Foo.lean --with github:owner/repo@v1.0
+                                              check against exact package references
+  lean-runtime check Foo.lean --timeout 60    bound one Lean invocation to 60 seconds
+  lean-runtime --timings check Foo.lean       append stable phase timings to the result
+
+Multi-file checks exit nonzero if any file is rejected. Header snapshots for
+warm re-checks are used by --watch and --repeat automatically; set
+LEAN_RUNTIME_HEADER_SNAPSHOTS=1 to enable them for one-shot checks.""",
+    )
     check.add_argument(
         "inputs",
         nargs="*",
-        help="FILE, legacy ENVIRONMENT FILE, or omit inside a Lake project; FILE may be -",
+        help="FILE..., DIRECTORY..., legacy ENVIRONMENT FILE, or omit inside a Lake "
+        "project; FILE may be -",
+    )
+    check.add_argument(
+        "--environment",
+        help="check the given FILEs inside this published environment",
     )
     check.add_argument(
         "--with",
@@ -652,7 +790,9 @@ Run `lean-runtime COMMAND --help` for examples and options.""",
     check.add_argument("--repeat", type=int, help="measure N repeated checks of one project file")
     check.add_argument("--warmup", type=int, default=1, help="warmups before --repeat samples")
     check.add_argument("--across", type=Path, help="check FILE across contexts in CONFIGURATION")
-    check.add_argument("--concurrency", type=int, default=1, help="workers for --across")
+    check.add_argument(
+        "--concurrency", type=int, default=1, help="workers for --across and multi-file checks"
+    )
     _add_policy(check)
 
     inspect = commands.add_parser("inspect", help="inspect a published environment")
@@ -933,6 +1073,10 @@ def main(argv: list[str] | None = None) -> int:
         args.mathlib = None if args.core else args.mathlib_version
     operation_started = time.monotonic()
     display_path: str | None = None
+    renderer = ConsoleRenderer(
+        mode="quiet" if args.quiet or getattr(args, "json", False) else None,
+        verbose=args.verbose,
+    )
     try:
         if args.command == "completion":
             print(_completion_script(args.shell), end="")
@@ -947,7 +1091,7 @@ def main(argv: list[str] | None = None) -> int:
         )
         runtime = Runtime(
             home=args.home,
-            on_event=None if args.quiet else _progress,
+            on_event=renderer,
             availability=selected_availability,
             libraries=args.libraries,
             max_download_bytes=selected_download_limit,
@@ -1190,7 +1334,13 @@ def main(argv: list[str] | None = None) -> int:
             _json(environment.inspect().to_dict())
             return 0
         if args.command == "build-and-publish":
-            access = runtime.check_publication_access(args.publish_to)
+            timeout_override = args.timeout
+            publisher = runtime.begin_publication(
+                args.publish_to,
+                auth_timeout=timeout_override if timeout_override is not None else 10,
+                registry_timeout=timeout_override if timeout_override is not None else 30,
+            )
+            access = publisher.check_access()
             if args.check_access:
                 _json(
                     envelope(_schema_for(args.command), ok=True, data=access.to_dict())
@@ -1203,7 +1353,7 @@ def main(argv: list[str] | None = None) -> int:
             environment = runtime.open_exact(
                 EnvironmentLock.load(args.lock),
                 name=args.name,
-                build_timeout=args.timeout,
+                build_timeout=timeout_override if timeout_override is not None else 1800,
                 accelerate=args.accelerate,
             )
             publication = runtime.publish_environment(
@@ -1213,6 +1363,7 @@ def main(argv: list[str] | None = None) -> int:
                 finalize=not args.platform_only,
                 sign=args.sign,
                 attest=args.attest,
+                publisher=publisher,
             ).to_dict()
             publication["consumer_command"] = (
                 f"lean-runtime --library {args.publish_to} download {args.lock}"
@@ -1487,10 +1638,15 @@ def main(argv: list[str] | None = None) -> int:
                 if args.include_downloads
                 else None
             )
+            gc_scratch = runtime.clean_scratch(
+                dry_run=not args.execute,
+                minimum_age_seconds=min(args.minimum_age_hours * 3600, 3600),
+            )
             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(),
                 }
                 _json(
                     envelope(
@@ -1500,11 +1656,17 @@ def main(argv: list[str] | None = None) -> int:
                     )
                 )
             else:
-                _render_cleanup(gc_report, gc_downloads)
+                _render_cleanup(gc_report, gc_downloads, gc_scratch)
             return 0
         if args.command == "check":
             if args.across is not None:
-                if len(args.inputs) != 1 or args.package_refs or args.include or args.project:
+                if (
+                    len(args.inputs) != 1
+                    or args.package_refs
+                    or args.include
+                    or args.project
+                    or args.environment
+                ):
                     raise ValueError("check --across requires exactly one FILE")
                 across_file = Path(args.inputs[0])
                 contexts = load_matrix(args.across)
@@ -1539,6 +1701,8 @@ def main(argv: list[str] | None = None) -> int:
                         "check --repeat requires positive samples and nonnegative warmups"
                     )
                 repeated_file = Path(args.inputs[0])
+                if os.environ.get(_HEADER_SNAPSHOTS_VARIABLE) is None:
+                    runtime.header_cache.enabled = True
                 for _ in range(args.warmup):
                     warm = runtime.check_file(
                         repeated_file, project=args.project, policy=_policy(args)
@@ -1576,6 +1740,8 @@ def main(argv: list[str] | None = None) -> int:
                 if not watched.is_file():
                     raise ValueError(f"watched Lean file does not exist: {watched}")
                 print(f"Watching {watched} · Ctrl-C to stop")
+                if os.environ.get(_HEADER_SNAPSHOTS_VARIABLE) is None:
+                    runtime.header_cache.enabled = True
                 previous: tuple[int, int] | None = None
                 while True:
                     stat = watched.stat()
@@ -1590,11 +1756,34 @@ def main(argv: list[str] | None = None) -> int:
                         )
                         _emit_result(watched_result, False)
                     time.sleep(args.watch_interval)
+            check_subject = (
+                Path(args.inputs[-1]).name
+                if args.inputs and args.inputs[-1] != "-"
+                else "stdin"
+                if args.inputs
+                else Path(args.project or ".").resolve().name
+            )
+            runtime.events.emit("check.started", "Checking Lean input", subject=check_subject)
             if args.project is not None and args.package_refs:
                 raise ValueError("check cannot combine --project with --with")
+            if args.environment is not None and (
+                args.package_refs or args.project or args.toolchain
+            ):
+                raise ValueError(
+                    "check --environment cannot be combined with --with, --project, or --toolchain"
+                )
+            legacy_environment = (
+                args.environment is None
+                and not args.package_refs
+                and len(args.inputs) == 2
+                and args.inputs[0] != "-"
+                and not Path(args.inputs[0]).exists()
+            )
             if not args.inputs:
                 if args.package_refs or args.include:
                     raise ValueError("project-wide check does not accept --with or --include")
+                if args.environment is not None:
+                    raise ValueError("check --environment requires at least one FILE")
                 result = runtime.check_project(
                     args.project or Path("."), toolchain=args.toolchain, policy=_policy(args)
                 )
@@ -1604,11 +1793,22 @@ def main(argv: list[str] | None = None) -> int:
                     raise ValueError("check with --with expects exactly one FILE")
                 environment = runtime.open_references(args.package_refs, toolchain=args.toolchain)
                 source_file = Path(args.inputs[0])
-            elif len(args.inputs) == 1:
-                if args.include:
-                    raise ValueError("local project checks do not accept --include")
-                source_file = Path(args.inputs[0])
-                if str(source_file) == "-":
+            elif legacy_environment:
+                if args.toolchain:
+                    raise ValueError("check --toolchain is only valid with --with")
+                if args.project:
+                    raise ValueError("check --project is only valid with a single FILE")
+                environment = runtime.environment(args.inputs[0])
+                source_file = Path(args.inputs[1])
+            elif "-" in args.inputs:
+                if len(args.inputs) != 1:
+                    raise ValueError("stdin (-) must be the only check input")
+                if args.environment is not None:
+                    environment = runtime.environment(args.environment)
+                    source_file = Path("-")
+                else:
+                    if args.include:
+                        raise ValueError("local project checks do not accept --include")
                     display_path = "<stdin>"
                     result = runtime.check(
                         sys.stdin.read(),
@@ -1616,23 +1816,26 @@ def main(argv: list[str] | None = None) -> int:
                         project=args.project,
                         policy=_policy(args),
                     )
+                    source_file = None
+            else:
+                selected_files = _expand_check_inputs(args.inputs)
+                if len(selected_files) > 1:
+                    if args.include:
+                        raise ValueError("multi-file checks do not accept --include")
+                    return _run_check_batch(runtime, selected_files, args)
+                if args.environment is not None:
+                    environment = runtime.environment(args.environment)
+                    source_file = selected_files[0]
                 else:
+                    if args.include:
+                        raise ValueError("local project checks do not accept --include")
                     result = runtime.check_file(
-                        source_file,
+                        selected_files[0],
                         toolchain=args.toolchain,
                         project=args.project,
                         policy=_policy(args),
                     )
-                source_file = None
-            else:
-                if len(args.inputs) != 2:
-                    raise ValueError("check expects FILE, ENVIRONMENT FILE, or FILE with --with")
-                if args.toolchain:
-                    raise ValueError("check --toolchain is only valid with --with")
-                if args.project:
-                    raise ValueError("check --project is only valid with a single FILE")
-                environment = runtime.environment(args.inputs[0])
-                source_file = Path(args.inputs[1])
+                    source_file = None
             if source_file is None:
                 pass
             elif str(source_file) == "-":
@@ -1672,9 +1875,11 @@ def main(argv: list[str] | None = None) -> int:
                 shared=args.shared,
             )
     except KeyboardInterrupt:
+        renderer.close()
         print("lean-runtime: interrupted", file=sys.stderr)
         return 130
     except (ResolutionError, MaterializationError) as exc:
+        renderer.close()
         details = {
             "phase": exc.phase,
             "command": list(exc.command),
@@ -1694,6 +1899,7 @@ def main(argv: list[str] | None = None) -> int:
             _print_operation_failure(exc, verbose=args.verbose)
         return 2
     except PublicationError as exc:
+        renderer.close()
         if getattr(args, "json", False):
             _json(
                 envelope(
@@ -1707,6 +1913,7 @@ def main(argv: list[str] | None = None) -> int:
             _print_publication_failure(exc)
         return exc.exit_code
     except (LeanRuntimeError, OSError, UnicodeError, ValueError, json.JSONDecodeError) as exc:
+        renderer.close()
         if getattr(args, "json", False):
             _json(
                 envelope(
@@ -1719,6 +1926,18 @@ def main(argv: list[str] | None = None) -> int:
         else:
             print(f"lean-runtime: {exc}", file=sys.stderr)
         return 2
+    if args.command in {"check", "check-file"}:
+        runtime.events.emit("check.completed", "Lean check completed", ok=result.ok)
+        total_ms = round((time.monotonic() - operation_started) * 1000)
+        accounted_ms = sum(timing.duration_ms for timing in result.timings)
+        result = replace(
+            result,
+            timings=(
+                PhaseTiming("command_preparation", max(0, total_ms - accounted_ms)),
+                *result.timings,
+            ),
+        )
+    renderer.close()
     _emit_result(result, args.json, display_path=display_path)
     if args.timings:
         print(render_timings(result.timings), file=sys.stderr)

{lean_runtime-2.9.1 → lean_runtime-2.10.0}/lean_runtime/console.py

@@ -215,6 +215,25 @@ class ConsoleRenderer:
     def _render_capability_required(self, event: RuntimeEvent) -> None:
         self._print(event.message)
 
+    def _render_check_started(self, event: RuntimeEvent) -> None:
+        if self.mode != "tty":
+            return
+        subject = str(event.data.get("subject") or "Lean input")
+        message = f"Checking {subject}…"
+        self.stream.write("\r" + self.style.cyan(message))
+        self.stream.flush()
+        self._line_length = len(message)
+
+    def _render_check_completed(self, _event: RuntimeEvent) -> None:
+        self._end_progress_line()
+
+    def _render_check_header_wait(self, event: RuntimeEvent) -> None:
+        module = str(event.data.get("module") or "Lean input")
+        self._print(f"Waiting for header snapshot initialization: {module}")
+
+    def _render_project_workspace_lock_wait(self, event: RuntimeEvent) -> None:
+        self._print(event.message)
+
     # -- low-level output -----------------------------------------------
 
     def _verbose_line(self, event: RuntimeEvent) -> None: