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

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

@@ -2,6 +2,22 @@
 
 ## 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

{lean_runtime-2.9.2/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.2
+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.2 → 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.2 → lean_runtime-2.10.0}/lean_runtime/cli.py

@@ -8,6 +8,7 @@ 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
@@ -24,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
@@ -40,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,
@@ -343,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:
@@ -657,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",
@@ -686,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")
@@ -1554,7 +1660,13 @@ def main(argv: list[str] | None = None) -> int:
             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)
@@ -1589,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)
@@ -1626,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()
@@ -1650,9 +1766,24 @@ def main(argv: list[str] | None = None) -> int:
             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)
                 )
@@ -1662,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(),
@@ -1674,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) == "-":

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

@@ -227,6 +227,13 @@ class ConsoleRenderer:
     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:

{lean_runtime-2.9.2 → lean_runtime-2.10.0}/lean_runtime/header_cache.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import hashlib
 import json
 import os
@@ -10,15 +11,26 @@ import tempfile
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, NamedTuple
 
+from .errors import EnvironmentError
 from .locking import FileLock
 from .serialization import sha256_id
 from .store import platform_compatibility
 
 if TYPE_CHECKING:
+    import threading
+
+    from .events import EventEmitter
     from .toolchains import ToolchainManager
 
+ENABLE_VARIABLE = "LEAN_RUNTIME_HEADER_SNAPSHOTS"
+_TRUTHY = {"1", "true", "on", "yes"}
+
+
+def _configured_enabled() -> bool:
+    return os.environ.get(ENABLE_VARIABLE, "").strip().lower() in _TRUTHY
+
 
 def _header_identity(source: str) -> str:
     """Return a conservative identity for the module header/import block."""
@@ -43,12 +55,34 @@ def _header_identity(source: str) -> str:
     return "".join(lines)
 
 
+class _SnapshotPaths(NamedTuple):
+    snapshot: Path
+    deps: Path
+    lock: Path
+
+    def valid(self) -> bool:
+        return self.snapshot.is_file() and self.deps.is_file()
+
+
 class LeanHeaderCache:
-    """Reuse Lean's native experimental import snapshots when the binary supports them."""
+    """Reuse Lean's native experimental import snapshots when the binary supports them.
+
+    Snapshots are keyed by exact toolchain, workspace identity, logical module
+    name, and import-block content, so distinct modules never share a snapshot.
+    Existing snapshots are loaded without holding any lock; only first-time
+    snapshot creation serializes behind a per-key file lock.
+    """
 
-    def __init__(self, home: Path, toolchains: ToolchainManager) -> None:
+    def __init__(
+        self,
+        home: Path,
+        toolchains: ToolchainManager,
+        events: EventEmitter | None = None,
+    ) -> None:
         self.home = home / "header-snapshots"
         self.toolchains = toolchains
+        self.events = events
+        self.enabled = _configured_enabled()
         self._support: dict[str, bool] = {}
         self._toolchain_keys: dict[str, str] = {}
 
@@ -95,37 +129,86 @@ class LeanHeaderCache:
         self._support[key] = supported
         return supported
 
-    @contextmanager
-    def command(
-        self,
-        toolchain: str,
-        workspace_identity: str,
-        source: str,
-        command: Sequence[str],
-    ) -> Iterator[list[str]]:
-        if not self.supported(toolchain):
-            yield list(command)
-            return
+    def _paths(
+        self, toolchain: str, workspace_identity: str, module: str, source: str
+    ) -> _SnapshotPaths:
         key = sha256_id(
             "header",
             {
                 "toolchain": self._toolchain_key(toolchain),
                 "workspace": workspace_identity,
+                "module": module,
                 "header": hashlib.sha256(_header_identity(source).encode()).hexdigest(),
             },
         ).removeprefix("header-")
         root = self.home / self._toolchain_key(toolchain)
         snapshot = root / f"{key}.snap"
-        deps = Path(str(snapshot) + ".deps")
-        root.mkdir(parents=True, exist_ok=True)
-        with FileLock(root / f"{key}.lock"):
-            if snapshot.is_file() and deps.is_file():
-                yield [*command[:-1], f"--incr-load={snapshot}", command[-1]]
+        return _SnapshotPaths(snapshot, Path(str(snapshot) + ".deps"), root / f"{key}.lock")
+
+    def discard(self, toolchain: str, workspace_identity: str, module: str, source: str) -> None:
+        """Quarantine a snapshot that produced timeout or staleness symptoms."""
+        paths = self._paths(toolchain, workspace_identity, module, source)
+        for path in (paths.snapshot, paths.deps):
+            with contextlib.suppress(OSError):
+                path.unlink(missing_ok=True)
+
+    @contextmanager
+    def _creation_lock(
+        self, paths: _SnapshotPaths, module: str, cancel: threading.Event | None
+    ) -> Iterator[None]:
+        """Acquire the per-key creation lock, announcing contention once."""
+        lock = FileLock(paths.lock, timeout=0)
+        try:
+            lock.__enter__()
+        except EnvironmentError:
+            if self.events is not None:
+                self.events.emit(
+                    "check.header_wait",
+                    f"Waiting for header snapshot initialization: {module}",
+                    phase="check",
+                    module=module,
+                )
+            lock = FileLock(paths.lock, cancel=cancel)
+            lock.__enter__()
+        try:
+            yield
+        finally:
+            lock.__exit__(None, None, None)
+
+    @contextmanager
+    def command(
+        self,
+        toolchain: str,
+        workspace_identity: str,
+        module: str,
+        source: str,
+        command: Sequence[str],
+        *,
+        cancel: threading.Event | None = None,
+    ) -> Iterator[list[str]]:
+        if not self.enabled or not self.supported(toolchain):
+            yield list(command)
+            return
+        paths = self._paths(toolchain, workspace_identity, module, source)
+        if paths.valid():
+            yield [*command[:-1], f"--incr-load={paths.snapshot}", command[-1]]
+            return
+        paths.snapshot.parent.mkdir(parents=True, exist_ok=True)
+        hit_after_wait = False
+        with self._creation_lock(paths, module, cancel):
+            if paths.valid():
+                hit_after_wait = True
+            else:
+                root = str(paths.snapshot.parent)
+                with tempfile.TemporaryDirectory(
+                    prefix=f".{paths.snapshot.stem}.", dir=root
+                ) as temporary_root:
+                    temporary = Path(temporary_root) / "header.snap"
+                    temporary_deps = Path(str(temporary) + ".deps")
+                    yield [*command[:-1], f"--incr-header-save={temporary}", command[-1]]
+                    if temporary.is_file() and temporary_deps.is_file():
+                        os.replace(temporary, paths.snapshot)
+                        os.replace(temporary_deps, paths.deps)
                 return
-            with tempfile.TemporaryDirectory(prefix=f".{key}.", dir=root) as temporary_root:
-                temporary = Path(temporary_root) / "header.snap"
-                temporary_deps = Path(str(temporary) + ".deps")
-                yield [*command[:-1], f"--incr-header-save={temporary}", command[-1]]
-                if temporary.is_file() and temporary_deps.is_file():
-                    os.replace(temporary, snapshot)
-                    os.replace(temporary_deps, deps)
+        if hit_after_wait:
+            yield [*command[:-1], f"--incr-load={paths.snapshot}", command[-1]]

{lean_runtime-2.9.2 → lean_runtime-2.10.0}/lean_runtime/locking.py

@@ -2,32 +2,70 @@
 
 from __future__ import annotations
 
+import contextlib
+import json
 import os
 import threading
 import time
+from collections.abc import Callable
 from pathlib import Path
 from types import TracebackType
-from typing import BinaryIO
+from typing import Any, BinaryIO
 
 from .errors import EnvironmentError
 
 
 class FileLock:
+    """One advisory cross-process lock.
+
+    ``owner`` is a small JSON-serializable description of the acquiring
+    operation; on POSIX it is written into the lock file while the lock is
+    held so that waiters can attribute their wait. ``on_wait`` is invoked at
+    most once, on first contention, with the current holder's description (or
+    ``None`` when it cannot be read).
+    """
+
     def __init__(
         self,
         path: Path,
         timeout: float = 300,
         cancel: threading.Event | None = None,
+        owner: dict[str, Any] | None = None,
+        on_wait: Callable[[dict[str, Any] | None], None] | None = None,
     ) -> None:
         self.path = path
         self.timeout = timeout
         self.cancel = cancel
+        self.owner = owner
+        self.on_wait = on_wait
         self._handle: BinaryIO | None = None
+        self._owner_written = False
+
+    def holder(self) -> dict[str, Any] | None:
+        """Best-effort description of the current lock holder."""
+        try:
+            value = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError):
+            return None
+        return value if isinstance(value, dict) else None
+
+    def _write_owner(self, handle: BinaryIO) -> None:
+        if self.owner is None or os.name == "nt":
+            return
+        try:
+            handle.seek(0)
+            handle.truncate()
+            handle.write(json.dumps({"pid": os.getpid(), **self.owner}).encode("utf-8"))
+            handle.flush()
+            self._owner_written = True
+        except (OSError, TypeError, ValueError):
+            self._owner_written = False
 
     def __enter__(self) -> FileLock:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         handle = self.path.open("a+b")
         started = time.monotonic()
+        announced = False
         while True:
             try:
                 if os.name == "nt":
@@ -51,8 +89,13 @@ class FileLock:
                         getattr(fcntl, "LOCK_EX") | getattr(fcntl, "LOCK_NB"),  # noqa: B009
                     )
                 self._handle = handle
+                self._write_owner(handle)
                 return self
             except OSError as error:
+                if not announced:
+                    announced = True
+                    if self.on_wait is not None:
+                        self.on_wait(self.holder())
                 if self.cancel is not None and self.cancel.is_set():
                     handle.close()
                     raise EnvironmentError(
@@ -74,6 +117,12 @@ class FileLock:
         handle = self._handle
         if handle is None:
             return
+        if self._owner_written:
+            with contextlib.suppress(OSError):
+                handle.seek(0)
+                handle.truncate()
+                handle.flush()
+            self._owner_written = False
         if os.name == "nt":
             import msvcrt
 

{lean_runtime-2.9.2 → lean_runtime-2.10.0}/lean_runtime/models.py

@@ -20,6 +20,8 @@ TimingPhase = Literal[
     "instance_creation",
     "input_staging",
     "command_preparation",
+    "workspace_lock",
+    "header_snapshot",
     "execution",
     "result_collection",
     "result_publication",
@@ -40,6 +42,8 @@ TIMING_PHASES = frozenset(
         "instance_creation",
         "input_staging",
         "command_preparation",
+        "workspace_lock",
+        "header_snapshot",
         "execution",
         "result_collection",
         "result_publication",