lean-runtime 2.5.0__tar.gz → 2.6.0__tar.gz

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## Unreleased
 
+## 2.6.0 - 2026-08-14
+
+- Make the local-project path a four-command workflow: `init`, `check`,
+  `build`, and `update`. New projects use the newest stable cataloged Mathlib
+  by default; `--core` opts out, while `--mathlib VERSION` selects a release.
+- Make `init` adopt an existing pinned Lake project without changing its graph,
+  or create a new project transactionally after its exact dependencies are
+  ready. `--plan`, `--offline`, `--max-download`, and `--seed-from` expose its
+  acquisition policy, and failed initialization leaves no partial project.
+- Add persistent discovery of exact local Lake graphs. `scan` registers existing
+  projects as zero-download seeds for future initialization and updates.
+- Preserve verified sparse-capsule build artifacts when materializing exact Git
+  sources for a mutable project, instead of throwing them away and forcing a
+  dependency rebuild.
+- Add explicit, transactional `update` to the newest cataloged Mathlib, with an
+  old/new revision and toolchain preview and rollback after failed adoption.
+- Include exact package revisions, Git tree hashes, and the shared workspace ID
+  in mutable-project check and build provenance.
+
 ## 2.5.0 - 2026-08-14
 
 - Make `lean-runtime init` create a concise `AGENTS.md` with build, checking,

{lean_runtime-2.5.0/lean_runtime.egg-info → lean_runtime-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.5.0
+Version: 2.6.0
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0
@@ -181,31 +181,34 @@ project = lean.setup(project="./my-project")
 result = project.check_file("./my-project/MyProject/Main.lean")
 ```
 
-Create a normal Lake project whose exact dependencies are shared automatically:
+Create a normal Lake project. The newest stable cataloged Mathlib is the
+default, and exact dependencies are shared automatically:
 
 ```bash
-lean-runtime init MyProof --mathlib
+lean-runtime init MyProof
 cd MyProof
-lean-runtime build .
+lean-runtime check MyProof/Basic.lean
+lean-runtime build
 ```
 
 `init` also writes an `AGENTS.md` with the project build, checking, dependency,
 and shared-package rules for coding agents. Pass `--no-agents` to omit it; an
-existing `AGENTS.md` is never overwritten.
+existing `AGENTS.md` is never overwritten. Use `--core` for no Mathlib, or
+`--mathlib 4.33.0` to select a cataloged release. `lean-runtime update`
+explicitly moves a project to the newest cataloged Mathlib after a preview.
 
-Existing repositories can preview and adopt the same layout individually or in
-bulk:
+Running `lean-runtime init .` in an existing pinned Lake project adopts its
+current exact graph without running `lake update`. If you already have many
+Lake checkouts, register them once as local dependency seeds:
 
 ```bash
-lean-runtime attach ~/research --recursive
-lean-runtime attach ~/research --recursive --execute
+lean-runtime scan ~/research
+lean-runtime init .
 ```
 
-The dry run reports blockers and estimated recovery without changing anything.
-Adoption preserves each root `.lake/build`, verifies both the override and
-ordinary Lake views, then replaces only generated package copies with links to
-the content-addressed store. `lean-runtime detach . --execute` materializes an
-independent project again.
+`init --plan` is side-effect free; `--max-download 500MiB` and `--offline`
+enforce cold-start policy. Advanced bulk migration remains available through
+`attach`, and `detach --execute` materializes an independent project again.
 
 One-shot helpers are available when setup reuse is unnecessary:
 

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/README.md

@@ -145,31 +145,34 @@ project = lean.setup(project="./my-project")
 result = project.check_file("./my-project/MyProject/Main.lean")
 ```
 
-Create a normal Lake project whose exact dependencies are shared automatically:
+Create a normal Lake project. The newest stable cataloged Mathlib is the
+default, and exact dependencies are shared automatically:
 
 ```bash
-lean-runtime init MyProof --mathlib
+lean-runtime init MyProof
 cd MyProof
-lean-runtime build .
+lean-runtime check MyProof/Basic.lean
+lean-runtime build
 ```
 
 `init` also writes an `AGENTS.md` with the project build, checking, dependency,
 and shared-package rules for coding agents. Pass `--no-agents` to omit it; an
-existing `AGENTS.md` is never overwritten.
+existing `AGENTS.md` is never overwritten. Use `--core` for no Mathlib, or
+`--mathlib 4.33.0` to select a cataloged release. `lean-runtime update`
+explicitly moves a project to the newest cataloged Mathlib after a preview.
 
-Existing repositories can preview and adopt the same layout individually or in
-bulk:
+Running `lean-runtime init .` in an existing pinned Lake project adopts its
+current exact graph without running `lake update`. If you already have many
+Lake checkouts, register them once as local dependency seeds:
 
 ```bash
-lean-runtime attach ~/research --recursive
-lean-runtime attach ~/research --recursive --execute
+lean-runtime scan ~/research
+lean-runtime init .
 ```
 
-The dry run reports blockers and estimated recovery without changing anything.
-Adoption preserves each root `.lake/build`, verifies both the override and
-ordinary Lake views, then replaces only generated package copies with links to
-the content-addressed store. `lean-runtime detach . --execute` materializes an
-independent project again.
+`init --plan` is side-effect free; `--max-download 500MiB` and `--offline`
+enforce cold-start policy. Advanced bulk migration remains available through
+`attach`, and `detach --execute` materializes an independent project again.
 
 One-shot helpers are available when setup reuse is unnecessary:
 

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/docs/cli.md

@@ -146,25 +146,32 @@ environment can replay offline.
 ## Existing projects and core Lean
 
 ```bash
-lean-runtime check-file Main.lean --toolchain 4.32.2
-lean-runtime check-file ./existing-project/MyProject/Main.lean
-lean-runtime build ./existing-project MyLibrary
-lean-runtime init MyProof --mathlib
-lean-runtime init MyProof --mathlib --no-agents
+lean-runtime check Main.lean --toolchain 4.32.2
+lean-runtime check ./existing-project/MyProject/Main.lean
+lean-runtime build
+lean-runtime init MyProof
+lean-runtime init MyProof --core
+lean-runtime init --plan --max-download 500MiB
+lean-runtime update --plan
+lean-runtime scan ~/research
 lean-runtime attach ~/research --recursive
 lean-runtime attach ~/research --recursive --execute
 lean-runtime detach ./existing-project --execute
 lean-runtime install 4.32.2
 ```
 
-Without `--with`, the environment-aware `check` command requires an environment
-identifier. `check-file` is the direct local-project route. When no
+`check FILE` is the direct standalone/local-project route; the legacy
+`check ENVIRONMENT FILE` spelling remains accepted. When no
 `--project` or `--toolchain` is supplied, it discovers the nearest directory
 containing a Lake configuration and `lean-toolchain`, then passes the actual
 project-relative file to `lake env lean`.
 
-`init` creates a standard core or Mathlib Lake library and attaches its exact
-cataloged dependencies. `attach` is read-only unless `--execute` is present;
+`init` defaults to the newest stable cataloged Mathlib, or adopts an existing
+pinned Lake project without changing its graph. `--core` opts out of Mathlib.
+It prepares dependencies before atomically publishing a new project. `update`
+is the explicit transactional move to the newest cataloged Mathlib; `scan`
+records exact existing graphs as future local seeds. `attach` is read-only
+unless `--execute` is present;
 recursive mode inventories a project tree, reports blockers and estimated disk
 recovery, and adopts each valid project transactionally. `detach` is likewise a
 preview unless `--execute` is present. Attached projects use shared mode by

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/docs/getting-started.md

@@ -18,33 +18,50 @@ Create a standard Lake library with the newest cataloged Mathlib release and
 shared exact dependencies:
 
 ```bash
-lean-runtime init MyProof --mathlib
+lean-runtime init MyProof
 cd MyProof
-lean-runtime build .
+lean-runtime check MyProof/Basic.lean
+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.
 
-Use `--mathlib 4.33.0` to select that release explicitly. Omit `--mathlib` for
-a core-only library. The root project remains an ordinary mutable Lake project;
+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;
 its dependency sources and build artifacts are reused by other projects with
 the same exact graph.
 
-For an existing project or a directory containing many projects, preview the
-migration before applying it:
+Before doing any work, `init --plan` reports the exact release, local reuse, and
+known download size. `--max-download 500MiB` refuses a larger transfer and
+`--offline` requires a matching local graph. Initialization is transactional:
+the target appears only after Lake and the shared dependency graph both verify.
+Project development requires one full Lake-capable Lean toolchain per Lean
+version. When it is absent, the plan says its Elan download size is unknown;
+`--offline` and `--max-download` fail closed instead of silently installing it.
+
+Dependency upgrades are explicit:
+
+```bash
+lean-runtime update --plan
+lean-runtime update
+```
+
+The update preview names both exact Mathlib revisions and toolchains. In a
+terminal, the second command asks for confirmation; use `--yes` in automation.
+
+For one existing pinned Lake project, preserve and adopt its current exact graph:
 
 ```bash
-lean-runtime attach .
-lean-runtime attach ~/research --recursive
-lean-runtime attach ~/research --recursive --execute
+lean-runtime init .
+lean-runtime scan ~/research
 ```
 
-The first two commands are read-only. Execution verifies the shared graph,
-replaces only generated package copies, and rolls back the swap if ordinary
-Lake cannot load the result. See [Local Lake projects](local-projects.md) for
-detachment, storage estimates, and the complete safety model.
+`scan` only records exact local graphs as possible future zero-download seeds.
+Advanced bulk migration remains available through `attach`. See [Local Lake
+projects](local-projects.md) for detachment, storage estimates, and the complete
+safety model.
 
 ## Run a file
 

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/docs/local-projects.md

@@ -22,10 +22,10 @@ managed environment, dependency list, or explicit toolchain is supplied:
 result = Runtime().check_file("./my-project/MyProject/Main.lean")
 ```
 
-The CLI equivalent is:
+The primary CLI equivalent is:
 
 ```bash
-lean-runtime check-file ./my-project/MyProject/Main.lean
+lean-runtime check ./my-project/MyProject/Main.lean
 ```
 
 The actual project-relative file is passed to `lake env lean`, so imports of
@@ -43,19 +43,46 @@ Ordinary Lake workspaces put remote dependencies and their build artifacts in
 each repository's `.lake/packages`. New projects can start in shared mode:
 
 ```bash
-lean-runtime init MyProof --mathlib
+lean-runtime init MyProof
 cd MyProof
-lean-runtime build .
+lean-runtime check MyProof/Basic.lean
+lean-runtime build
 ```
 
 The generated files are a standard Lake project plus a small
 `lean-runtime.toml`. Root build outputs stay local; exact dependencies are
-shared. Select a cataloged release with `--mathlib 4.33.0`, or omit `--mathlib`
-for a core-only library. `init` also creates an `AGENTS.md` describing the safe
+shared. 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
 overwrites an existing guide.
 
-For one existing project, preview before changing anything:
+Initialization acquires and verifies the exact graph before publishing the
+target directory. Use `--plan` for a side-effect-free cost report, `--offline`
+to require local data, `--max-download SIZE` to enforce a transfer ceiling, or
+`--seed-from PROJECT` to name an exact local donor.
+The plan separately reports whether the full Lake-capable toolchain is already
+installed. Because Elan does not publish a preflight byte count, a missing full
+toolchain is rejected under `--offline` or `--max-download` rather than silently
+bypassing the policy.
+
+For an existing pinned project, `lean-runtime init .` adopts its current
+manifest without changing versions. Register a collection once with
+`lean-runtime scan ~/research`; future exact matches are preferred over
+downloads automatically.
+
+Move an adopted TOML project to the newest cataloged Mathlib explicitly:
+
+```bash
+lean-runtime update --plan
+lean-runtime update
+```
+
+The plan reports old and new release, commit, toolchain, local donor, and known
+download bytes. Acquisition happens before metadata changes, and failures
+restore the prior Lake files and attachment metadata.
+
+For advanced bulk onboarding, preview before changing anything:
 
 ```bash
 lean-runtime attach .

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/lean_runtime/__init__.py

@@ -59,6 +59,9 @@ from .project_sharing import (
     AdoptionResult,
     DetachmentPlan,
     ProjectAdoption,
+    ProjectInitPlan,
+    ProjectScanResult,
+    ProjectUpdatePlan,
 )
 from .projects import (
     ProjectContext,
@@ -85,6 +88,9 @@ __all__ = [
     "AdoptionPlan",
     "AdoptionResult",
     "DetachmentPlan",
+    "ProjectInitPlan",
+    "ProjectScanResult",
+    "ProjectUpdatePlan",
     "EnvironmentComparison",
     "ComparisonEntry",
     "PortableCopyInfo",

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/lean_runtime/cli.py

@@ -18,8 +18,8 @@ from .lake import ROOT_MODULE
 from .lockfiles import EnvironmentLock
 from .matrix import load_matrix
 from .models import ExecutionResult, PhaseTiming
-from .policies import ExecutionPolicy, format_byte_size
-from .project_sharing import AdoptionPlan
+from .policies import ExecutionPolicy, format_byte_size, parse_byte_size
+from .project_sharing import AdoptionPlan, ProjectInitPlan, ProjectUpdatePlan
 from .projects import discover_project, project_publication_workflow
 from .runtime import Runtime
 from .specs import EnvironmentSpec
@@ -177,6 +177,46 @@ def _render_adoption_plan(plan: AdoptionPlan) -> None:
     print(f"Potential recovery:        {format_byte_size(plan.estimated_reclaimable_bytes)}")
 
 
+def _render_init_plan(plan: ProjectInitPlan) -> None:
+    if plan.action == "adopt":
+        state = "already attached" if plan.already_attached else "ready to attach"
+        print(f"Existing Lake project · {plan.toolchain} · {state}")
+        print(f"Exact dependencies: {len(plan.packages)} package(s); versions unchanged")
+        return
+    context = f"Mathlib {plan.mathlib_version}" if plan.mathlib_version else "core Lean"
+    print(f"Create {plan.root.name} · {context} · {plan.toolchain}")
+    if not plan.toolchain_installed:
+        print("Full Lake toolchain: download required (size not published by Elan)")
+    if plan.seed_root is not None:
+        print(f"Reuse exact local graph: {plan.seed_root}")
+        print("Download: 0 B")
+    elif plan.download_bytes is not None:
+        print(f"Download: {format_byte_size(plan.download_bytes)}")
+    else:
+        print("Download: unknown (no compatible published artifact could be priced)")
+
+
+def _render_update_plan(plan: ProjectUpdatePlan) -> None:
+    if not plan.changed:
+        print(f"Already current: Mathlib {plan.target_version} · {plan.target_toolchain}")
+        return
+    print(
+        f"Mathlib {plan.current_version} → {plan.target_version} · "
+        f"{plan.current_toolchain} → {plan.target_toolchain}"
+    )
+    if not plan.toolchain_installed:
+        print("Full Lake toolchain: download required (size not published by Elan)")
+    if plan.seed_root is not None:
+        print(f"Reuse exact local graph: {plan.seed_root}")
+        print("Download: 0 B")
+    elif plan.download_bytes is not None:
+        print(f"Download: {format_byte_size(plan.download_bytes)}")
+    else:
+        print("Download: unknown")
+    for blocker in plan.blockers:
+        print(f"Blocker: {blocker}")
+
+
 def _progress(event: RuntimeEvent) -> None:
     package = f" [{event.data['package']}]" if "package" in event.data else ""
     print(f"lean-runtime: {event.kind}{package}: {event.message}", file=sys.stderr)
@@ -383,13 +423,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 with --with packages or in a published environment"
-    )
+    check = commands.add_parser("check", help="check one Lean file in its exact context")
     check.add_argument(
         "inputs",
         nargs="+",
-        help="FILE with --with, otherwise ENVIRONMENT FILE; FILE may be - for stdin",
+        help="FILE, or legacy ENVIRONMENT FILE; FILE may be - for stdin",
     )
     check.add_argument(
         "--with",
@@ -399,7 +437,8 @@ def parser() -> argparse.ArgumentParser:
         metavar="REFERENCE",
         help="repeatable github:owner/repository@tag-or-commit package reference",
     )
-    check.add_argument("--toolchain", help="override the toolchain discovered from --with packages")
+    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(
         "--include", action="append", default=[], type=Path, help="additional Lean source file"
     )
@@ -475,7 +514,7 @@ def parser() -> argparse.ArgumentParser:
     _add_policy(raw)
 
     build = commands.add_parser("build", help="build an existing Lake project")
-    build.add_argument("project", type=Path)
+    build.add_argument("project", type=Path, nargs="?", default=Path("."))
     build.add_argument("targets", nargs="*")
     build.add_argument("--toolchain")
     build.add_argument("--timeout", type=float, default=900)
@@ -495,15 +534,30 @@ def parser() -> argparse.ArgumentParser:
     )
     build.add_argument("--json", action="store_true")
 
-    init = commands.add_parser("init", help="create a standard Lake project in shared mode")
-    init.add_argument("path", type=Path)
-    init.add_argument(
+    init = commands.add_parser(
+        "init", help="create a latest-Mathlib project or adopt an existing Lake project"
+    )
+    init.add_argument("path", type=Path, nargs="?", default=Path("."))
+    init_context = init.add_mutually_exclusive_group()
+    init_context.add_argument(
         "--mathlib",
         nargs="?",
         const="latest",
+        default="latest",
         help="use the newest cataloged Mathlib, or select a version such as 4.33.0",
     )
+    init_context.add_argument(
+        "--core",
+        dest="mathlib",
+        action="store_const",
+        const=None,
+        help="create a core-only project",
+    )
     init.add_argument("--toolchain")
+    init.add_argument("--seed-from", type=Path, help="reuse an exact local project or project tree")
+    init.add_argument("--plan", action="store_true", help="show cost and reuse without changes")
+    init.add_argument("--offline", action="store_true", help="require exact local dependencies")
+    init.add_argument("--max-download", metavar="SIZE", help="fail above SIZE, e.g. 500MiB")
     init.add_argument(
         "--no-agents",
         dest="agents",
@@ -512,6 +566,22 @@ def parser() -> argparse.ArgumentParser:
     )
     init.add_argument("--json", action="store_true")
 
+    scan = commands.add_parser(
+        "scan", help="register local Lake projects as reusable exact dependency seeds"
+    )
+    scan.add_argument("path", type=Path, nargs="?", default=Path("."))
+    scan.add_argument("--no-recursive", dest="recursive", action="store_false")
+    scan.add_argument("--json", action="store_true")
+
+    update = commands.add_parser("update", help="move this project to the latest stable Mathlib")
+    update.add_argument("path", type=Path, nargs="?", default=Path("."))
+    update.add_argument("--seed-from", type=Path, help="reuse an exact local project or tree")
+    update.add_argument("--plan", action="store_true", help="show the update without changes")
+    update.add_argument("--yes", action="store_true", help="apply without an interactive prompt")
+    update.add_argument("--offline", action="store_true", help="require exact local dependencies")
+    update.add_argument("--max-download", metavar="SIZE", help="fail above SIZE, e.g. 500MiB")
+    update.add_argument("--json", action="store_true")
+
     attach = commands.add_parser(
         "attach", help="plan or adopt shared dependencies for existing Lake projects"
     )
@@ -574,31 +644,89 @@ def main(argv: list[str] | None = None) -> int:
     args = parser().parse_args(argv)
     operation_started = time.monotonic()
     try:
+        selected_availability = (
+            "local" if args.command in {"init", "update"} and args.offline else args.availability
+        )
+        selected_download_limit = (
+            parse_byte_size(args.max_download)
+            if args.command in {"init", "update"} and args.max_download is not None
+            else None
+        )
         runtime = Runtime(
             home=args.home,
             on_event=None if args.quiet else _progress,
-            availability=args.availability,
+            availability=selected_availability,
             libraries=args.libraries,
+            max_download_bytes=selected_download_limit,
             publisher_verification=args.publisher_verification,
             trusted_publisher=args.trusted_publisher,
             trusted_issuer=args.trusted_issuer,
             verification_tool=args.verification_tool,
         )
         if args.command == "init":
+            init_plan = runtime.plan_project_init(
+                args.path,
+                mathlib=args.mathlib,
+                toolchain=args.toolchain,
+                seed_from=args.seed_from,
+            )
+            if args.plan:
+                if args.json:
+                    _json(init_plan.to_dict())
+                else:
+                    _render_init_plan(init_plan)
+                return 0
+            if not args.json:
+                _render_init_plan(init_plan)
             init_result = runtime.init_project(
                 args.path,
                 mathlib=args.mathlib,
                 toolchain=args.toolchain,
                 agents=args.agents,
+                seed_from=args.seed_from,
             )
             if args.json:
                 _json(init_result.to_dict())
             else:
-                print(f"Created and attached {init_result.root}")
+                verb = "Ready" if init_plan.action == "create" else "Attached"
+                print(f"{verb}: {init_result.root}")
                 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 .")
+                print(f"Next: cd {init_result.root} && lean-runtime build")
+            return 0
+        if args.command == "scan":
+            scan_result = runtime.scan_projects(args.path, recursive=args.recursive)
+            if args.json:
+                _json(scan_result.to_dict())
+            else:
+                print(f"Registered {len(scan_result.projects)} Lake project(s)")
+                for project_root in scan_result.projects:
+                    print(f"  {project_root}")
+            return 0
+        if args.command == "update":
+            update_plan = runtime.plan_project_update(args.path, seed_from=args.seed_from)
+            if not args.json:
+                _render_update_plan(update_plan)
+            if args.plan or not update_plan.changed or not update_plan.ready:
+                if args.json:
+                    _json({**update_plan.to_dict(), "applied": False})
+                return 0 if update_plan.ready else 1
+            apply_update = args.yes
+            if not apply_update and sys.stdin.isatty() and not args.json:
+                answer = input("Apply this update? [Y/n] ").strip().lower()
+                apply_update = answer in {"", "y", "yes"}
+            if not apply_update:
+                if args.json:
+                    _json({**update_plan.to_dict(), "applied": False})
+                else:
+                    print("No changes made. Re-run with --yes to apply noninteractively.")
+                return 0
+            runtime.update_project(args.path, seed_from=args.seed_from)
+            if args.json:
+                _json({**update_plan.to_dict(), "applied": True})
+            else:
+                print(f"Updated and attached: {update_plan.root}")
             return 0
         if args.command == "attach":
             adoption_plan = runtime.plan_project_adoption(args.path, recursive=args.recursive)
@@ -1042,19 +1170,44 @@ def main(argv: list[str] | None = None) -> int:
                 _render_cleanup(gc_report, gc_downloads)
             return 0
         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 len(args.inputs) != 1:
                     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) == "-":
+                    result = runtime.check(
+                        sys.stdin.read(),
+                        toolchain=args.toolchain,
+                        project=args.project,
+                        policy=_policy(args),
+                    )
+                else:
+                    result = runtime.check_file(
+                        source_file,
+                        toolchain=args.toolchain,
+                        project=args.project,
+                        policy=_policy(args),
+                    )
+                source_file = None
             else:
                 if len(args.inputs) != 2:
-                    raise ValueError("check expects ENVIRONMENT FILE, or FILE with --with")
+                    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])
-            if str(source_file) == "-":
+            if source_file is None:
+                pass
+            elif str(source_file) == "-":
                 if args.include:
                     raise ValueError("stdin entrypoints cannot be combined with --include")
                 result = environment.check(sys.stdin.read(), policy=_policy(args))

{lean_runtime-2.5.0 → lean_runtime-2.6.0}/lean_runtime/models.py

@@ -106,6 +106,7 @@ class ProjectProvenance:
     manifest_digest: str | None
     git_revision: str | None
     git_dirty: bool | None
+    workspace_id: str | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return asdict(self)