leanwarp 0.2.3__py3-none-any.whl

leanwarp-0.2.3.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.5
+Name: leanwarp
+Version: 0.2.3
+Summary: Check and verify Lean proofs on LeanWarp from the command line, MCP or Python
+Project-URL: Repository, https://github.com/Isagoge-Labs/LeanWarp-SDK
+Project-URL: Homepage, https://isagoge.in
+Project-URL: Documentation, https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/README.md
+Project-URL: Issues, https://github.com/Isagoge-Labs/LeanWarp-SDK/issues
+Project-URL: Changelog, https://github.com/Isagoge-Labs/LeanWarp-SDK/releases
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,formal-verification,lean,lean4,mathlib,mcp,theorem-proving
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.12
+Requires-Dist: httpcore<2,>=1.0.9
+Requires-Dist: httpx<1,>=0.28.1
+Requires-Dist: mcp<2,>=1.28.1
+Requires-Dist: pathspec<2,>=1.1
+Requires-Dist: pydantic<3,>=2.12
+Provides-Extra: test
+Requires-Dist: pytest<10,>=8.4; extra == 'test'
+Description-Content-Type: text/markdown
+
+<h1><img src="https://raw.githubusercontent.com/Isagoge-Labs/LeanWarp-SDK/main/docs/assets/leanwarp-banner.svg" alt="LeanWarp" width="960"></h1>
+
+LeanWarp checks and verifies Lean 4 proofs on hosted workers that stay warm
+between edits. This SDK is how you and your agents use it: the `leanwarp`
+command, an MCP server and a Python library.
+
+**[Get started](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/getting-started.md)** · [Agent setup](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/agents.md) ·
+[Reference](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md) ·
+[HTTP API](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/http-api.md) · [Website](https://isagoge.in/leanwarp)
+
+## What it does
+
+| Operation | What you get | CLI |
+| --- | --- | --- |
+| Check | Lean's errors and warnings for a file; `--draft` reuses Lean's work on the unchanged part while you edit. | `leanwarp check` |
+| Inspect | The goals and local context at a position in a proof. | `leanwarp inspect` |
+| Try tactics | Several tactics from the same captured goal: which close it, which leave goals, which fail. The file is not edited. | `leanwarp try-tactics` |
+| Verify | Whether a declaration proves exactly the statement you give, checked by Lean's kernel. | `leanwarp verify` |
+| Holes | Every `sorry` and `?_` in a file, with its position, and the goals of the first 16. | `leanwarp holes` |
+| Suggest | A tactic that closes a hole, accepted only if nothing else changes and the proof gains no unproved lemma or extra axiom. `apply` writes it into the file. | `leanwarp suggest`, `leanwarp apply` |
+| Sorry to lemma | The proof of each theorem that still has a `sorry` moved into a new named lemma the theorem then uses; the lemma keeps its `sorry`. `apply` writes it. | `leanwarp sorry2lemma` |
+| Declarations | The declarations a file adds, with their types and dependencies. | `leanwarp declarations` |
+| Check files | Up to 64 files checked in one operation. | `leanwarp check-files` |
+
+The [reference](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md#commands)
+lists every command and option; `leanwarp skill --reference` prints it.
+
+### Coming soon
+
+These are planned and not available yet:
+
+- **Proof simplification**: replace a proof with a shorter one that still checks.
+- **`have` extraction**: lift named `have` blocks into top-level lemmas.
+- **Batch repair**: fill several holes in one operation.
+
+## Install in two steps
+
+**1. Install.** In a terminal, with [uv](https://docs.astral.sh/uv/getting-started/installation/):
+
+```sh
+uv tool install leanwarp && leanwarp setup
+```
+
+This installs the `leanwarp` command and its MCP server from
+[PyPI](https://pypi.org/project/leanwarp/). `leanwarp setup` adds the LeanWarp
+skill and MCP server to Claude Code, Codex and Cursor where they are installed,
+and the skill to `~/.agents/skills`. It runs on Linux, macOS and WSL. You don't
+need Lean installed: LeanWarp runs Lean and Mathlib for you.
+
+Or paste this into your agent:
+
+> Install LeanWarp: run `uv tool install leanwarp && leanwarp setup`, then ask me
+> to sign in.
+
+Already have LeanWarp 0.2 from GitHub? Its `leanwarp-sdk` tool owns the
+`leanwarp` command, so replace it instead:
+
+```sh
+uv tool uninstall leanwarp-sdk && uv tool install leanwarp && leanwarp setup
+```
+
+**2. Sign in**, in your own terminal:
+
+```sh
+leanwarp auth login
+```
+
+It opens the dashboard to create an API key; paste the key at the hidden prompt.
+Never paste it into an agent conversation. Then restart your agent.
+
+When a new release is out, results include `update_available`; run
+`leanwarp update` to upgrade and refresh the installed skills.
+
+## Quick start
+
+From your Lean project or one of the [examples](https://github.com/Isagoge-Labs/LeanWarp-SDK/tree/main/examples):
+
+```sh
+leanwarp doctor              # which environment this project runs on
+leanwarp connect             # create the project's workspace
+leanwarp check LeanWarpExample.lean
+```
+
+If a command returns `success: null` (exit `3`), run `leanwarp wait` until it
+finishes before submitting another operation. Then verify:
+
+```sh
+leanwarp verify LeanWarpExample.lean \
+  --declaration add_zero_example --target '∀ n : Nat, n + 0 = n'
+```
+
+Wait for that operation to finish too, then run `leanwarp stop` when you are done.
+
+Every command prints one JSON object. Results start with `success`: `true` when
+the check passed or the proof was verified, `false` when it did not, and `null`
+while the work is still running, in which case run `leanwarp wait`. The exit code
+says the same thing: `0` passed, `1` did not pass, `2` the command failed, `3`
+still running.
+
+## Use with an agent
+
+Give your agent the project directory and this instruction:
+
+> Run `leanwarp skill` and follow it. Use LeanWarp to check this Lean project
+> and verify proofs against their intended statements. Reuse the workspace
+> while you edit, and run `leanwarp stop` when you are done.
+
+For MCP clients, add the server `leanwarp --project /absolute/path/to/project mcp`,
+or `uvx leanwarp --project /absolute/path/to/project mcp`
+without installing. It uses the same key and project state as the CLI. See [agent setup](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/agents.md).
+Keep API keys out of prompts, source files and tool arguments.
+
+## Your project and its environment
+
+LeanWarp uploads only your `.lean` files. Lean, Mathlib and every other
+dependency come from an **environment**: a Lean release with Mathlib, already
+built on LeanWarp's workers. Run `leanwarp environments` to list them.
+`leanwarp files` lists what would upload; patterns in `.gitignore` and
+`.leanwarpignore` leave files out.
+
+`leanwarp connect` picks the environment for you:
+
+- If your project's `lean-toolchain` and `lake-manifest.json` match an
+  environment, it uses that one, so results agree with your local build.
+- If your project has neither file, as with a folder of `.lean` files, it uses
+  the only served environment, or the newest served stable Lean release when there are several.
+- If they match no environment, it stops and lists the ones available. Run
+  `leanwarp connect --environment NAME` to check your files there anyway; they
+  then compile against that environment's Lean and Mathlib.
+
+To start a new project, copy one of the [examples](https://github.com/Isagoge-Labs/LeanWarp-SDK/tree/main/examples), which match the
+environments LeanWarp serves.
+
+## Billing
+
+You pay from prepaid credit, billed by the second while a worker runs. Run
+`leanwarp resources` to see the published worker's starting minute price, whether
+charges depend on usage, startup credit hold and idle timeout. LeanWarp selects
+the worker. Use `leanwarp connect --max-spend 2` to create a workspace with a $2
+cap, or edit an existing cap in the dashboard. Reconnecting without a cap keeps
+the saved cap.
+
+When the worker uses usage billing, CPU and RAM charges increase independently
+above their reserved baselines. The starting rate is a paid minimum while the
+worker runs, including idle time. Bursting depends on available host capacity.
+Otherwise, the listed minute rate applies for the time the worker runs. Existing
+workspaces keep their saved billing terms.
+
+A worker starts with your first operation and stays warm between calls. Run
+`leanwarp stop` when finished; closing the SDK client or your terminal does not
+stop it. Unused held credit is released once shutdown and final usage are confirmed.
+Stopping keeps your uploaded files and
+completed results; the next operation reconstructs the worker. Set a spending cap
+for each workspace in the [dashboard](https://isagoge.in/dashboard).
+
+## Concepts
+
+| Term | Meaning |
+| --- | --- |
+| Environment | A Lean release with Mathlib, prebuilt on LeanWarp, such as `lean-4.26-mathlib`. |
+| Workspace | Your project's files on LeanWarp. One per project; creating it starts no compute. |
+| Worker | The machine that runs Lean for a workspace. It starts on demand and stays warm. |
+| Operation | One request, such as a check or a verification, and its result. |
+| Revision | A numbered version of the workspace's files. Each result names the one it checked. |
+| Receipt | The part of a verification result that records exactly what was checked. |
+
+## Documentation
+
+| Start here | Reference |
+| --- | --- |
+| [Verify your first proof](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/getting-started.md) | [Commands](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md#commands) |
+| [Set up an agent with the CLI or MCP](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/agents.md) | [Results and exit codes](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md#results) |
+| [Use the Python library](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md#python) | [Recover an interrupted request](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md#recovery) |
+| [Call the HTTP API directly](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/docs/http-api.md) | [Credentials, credit and limits](https://github.com/Isagoge-Labs/LeanWarp-SDK/blob/main/src/leanwarp_cloud/skills/leanwarp/references/usage.md#credentials-credit-and-limits) |
+
+The agent instructions ship with the package: `leanwarp skill` prints the
+workflow and `leanwarp skill --reference` the full reference. Run
+`leanwarp --help` or `leanwarp COMMAND --help` for arguments.

leanwarp-0.2.3.dist-info/RECORD

@@ -0,0 +1,24 @@
+leanwarp_cloud/__init__.py,sha256=KjZcgY1w6u6QMOpR8gf9C2AjDC5bUqoozNo0fitnCRU,721
+leanwarp_cloud/_version.py,sha256=GLCWRRSidfCx1EAkeWvGXJTypRbCHyx5ADAZxr17P0o,295
+leanwarp_cloud/agents.py,sha256=-C9v7XvjZoqrllU3-F7hjvrE78M4mw93HtwTon0JIgU,6571
+leanwarp_cloud/amounts.py,sha256=VYMR3JEkpJAsb0DqE_j3nuwQTmWA1-5MYZYkXZEeZpM,806
+leanwarp_cloud/cli.py,sha256=ugmGiIb668-POBRNB9t8WoDxH79ZShvHdjws4Ya4nto,26905
+leanwarp_cloud/client.py,sha256=YCNFXeY0ebKuBJKPr_N_CydsxSPrLbo333apL6oS_lI,30860
+leanwarp_cloud/config.py,sha256=nA9cLTlglm4F_Lt9UesrnAdkcFMzYw8Gvvto7QG2K_I,3037
+leanwarp_cloud/edits.py,sha256=DtzZ0_L_ujQ1M6HH9ExDdHHs_qhHlt1XWrOZkd-mr7s,3070
+leanwarp_cloud/endpoints.py,sha256=dfSWDmpfQjHH2nB2XiPB1sjG9EP9Jue18W4OmAlkfZM,1493
+leanwarp_cloud/mcp_server.py,sha256=FgHncDCNFYMvX885i3Ru06FDXwBZorwGDDD52xN0ynY,23249
+leanwarp_cloud/outcome.py,sha256=b84jKHBBkC5f3JLqa-i3G0O4G1QID2irLSWsAiLLc0w,4907
+leanwarp_cloud/project.py,sha256=rxYNZj2mquy4vHf33g1Vdfo1nR41b0YP3OVLDox1I7A,24441
+leanwarp_cloud/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+leanwarp_cloud/resources.py,sha256=h446GgXmraDjgC1q0j_xhFdSGYC41J06Ok932V8-gD0,1712
+leanwarp_cloud/session.py,sha256=TP_ewzLVFm9WocP9JjY1_KWVMTnNGfoK42dYrnXVz_g,59138
+leanwarp_cloud/transport.py,sha256=t1V-J5hQo5pwyr_YwSO2IxQ0IsmSyxwBy5riBn-znlg,7695
+leanwarp_cloud/updates.py,sha256=tjEajpdMuNTAuQmx_69nafbocTGq0Fa2cqxwOE4xABA,5464
+leanwarp_cloud/skills/leanwarp/SKILL.md,sha256=SPS2vU2K1G7FI1QyzttrYV85uVfLyG6M7bCom5Z8ntQ,11762
+leanwarp_cloud/skills/leanwarp/references/usage.md,sha256=fr5u_8JQuO-fQ-qXMor_SgF5R9WeB64nTImw7QYJm8g,30158
+leanwarp-0.2.3.dist-info/METADATA,sha256=pqZNZaYyvNsQV9O-XxG3Dq8_fM_diTrxtehHHVMxARs,11121
+leanwarp-0.2.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+leanwarp-0.2.3.dist-info/entry_points.txt,sha256=H3r3aaETa4w3OaKOnPzJHXlFW0TTh1720MFYpgbLrB8,53
+leanwarp-0.2.3.dist-info/licenses/LICENSE,sha256=gElcqYwHBv8HCj8Ug0QNdTDu-HHmPi5mn8KBUrGOC1s,1069
+leanwarp-0.2.3.dist-info/RECORD,,

leanwarp-0.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

leanwarp-0.2.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+leanwarp = leanwarp_cloud.cli:main

leanwarp-0.2.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isagoge Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

leanwarp_cloud/__init__.py

@@ -0,0 +1,25 @@
+"""Client for hosted LeanWarp; mathematical execution remains server-side."""
+
+from ._version import __version__
+from .client import LeanWarpCloud, LeanWarpCloudError, OperationTimeout
+from .config import load_client
+from .outcome import OperationOutcome
+from .project import UploadPlan, collect_lean_sources, plan_upload
+from .session import ProjectSession, SessionError, UsageError, WaitError, check_project
+
+__all__ = [
+    "LeanWarpCloud",
+    "LeanWarpCloudError",
+    "OperationOutcome",
+    "OperationTimeout",
+    "ProjectSession",
+    "SessionError",
+    "UploadPlan",
+    "UsageError",
+    "WaitError",
+    "__version__",
+    "check_project",
+    "collect_lean_sources",
+    "load_client",
+    "plan_upload",
+]

leanwarp_cloud/_version.py

@@ -0,0 +1,8 @@
+"""The installed SDK version, shared by the command line and the HTTP client."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("leanwarp")
+except PackageNotFoundError:  # Imported from a source tree without installation.
+    __version__ = "0.0.0"

leanwarp_cloud/agents.py

@@ -0,0 +1,173 @@
+"""Install the LeanWarp skill and MCP server for the agents on this machine.
+
+Installing a Python package cannot run code, so `leanwarp setup` does this step.
+Each agent is set up only when its configuration directory exists, unless named.
+The skill directory is LeanWarp's own and is replaced; an agent's MCP
+configuration only gains a `leanwarp` entry when it has none, and is never
+otherwise changed.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import tomllib
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Literal
+
+AgentName = Literal["claude-code", "codex", "cursor", "agents"]
+AGENTS: tuple[AgentName, ...] = ("claude-code", "codex", "cursor", "agents")
+_SKILL_FILES = ("SKILL.md", "references/usage.md")
+
+Run = Callable[..., subprocess.CompletedProcess[str]]
+
+
+def _run(command: Sequence[str], cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(  # noqa: S603 - fixed arguments, no shell
+        list(command), capture_output=True, text=True, check=False, timeout=60, cwd=cwd
+    )
+
+
+@dataclass(frozen=True)
+class _Agent:
+    name: AgentName
+    home: Path
+    # Where its skills live, if it reads skills.
+    skills: Path | None
+
+
+def _agents(home: Path, environ: dict[str, str]) -> dict[AgentName, _Agent]:
+    claude = Path(environ.get("CLAUDE_CONFIG_DIR") or home / ".claude")
+    codex = Path(environ.get("CODEX_HOME") or home / ".codex")
+    return {
+        "claude-code": _Agent("claude-code", claude, claude / "skills"),
+        "codex": _Agent("codex", codex, codex / "skills"),
+        "cursor": _Agent("cursor", home / ".cursor", None),
+        "agents": _Agent("agents", home / ".agents", home / ".agents" / "skills"),
+    }
+
+
+def _install_skill(skills: Path) -> str:
+    target = skills / "leanwarp"
+    for name in _SKILL_FILES:
+        path = target / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        source = files("leanwarp_cloud").joinpath(f"skills/leanwarp/{name}")
+        path.write_text(source.read_text(encoding="utf-8"), encoding="utf-8")
+    return str(target)
+
+
+def _command() -> str:
+    """The `leanwarp` this machine runs, so an MCP client finds it without a PATH."""
+    return shutil.which("leanwarp") or "leanwarp"
+
+
+def _claude_mcp(home: Path, run: Run) -> str:
+    """Add the server for the user, from the home folder, so an entry in the current
+    project's `.mcp.json` is never taken for the user-wide one."""
+    try:
+        added = run(
+            ["claude", "mcp", "add", "--scope", "user", "leanwarp", "--", _command(), "mcp"],
+            cwd=home,
+        )
+    except FileNotFoundError:
+        return "claude_cli_not_found"
+    except (OSError, subprocess.SubprocessError):
+        return "failed"
+    if added.returncode == 0:
+        return "configured"
+    # Claude Code reports an existing user entry as "already exists in user config".
+    return "already_configured" if "already exists" in added.stdout + added.stderr else "failed"
+
+
+def _codex_servers(text: str) -> dict[str, Any] | None:
+    """The config's MCP servers as TOML reads them, or None if it cannot be read."""
+    try:
+        servers = tomllib.loads(text).get("mcp_servers", {})
+    except tomllib.TOMLDecodeError:
+        return None
+    return servers if isinstance(servers, dict) else None
+
+
+def _codex_mcp(home: Path) -> str:
+    config = home / "config.toml"
+    text = config.read_text(encoding="utf-8") if config.exists() else ""
+    # Read the TOML, not its spelling: `[mcp_servers."leanwarp"]` is the same table.
+    servers = _codex_servers(text)
+    if servers is None:
+        return "unreadable_config"
+    if "leanwarp" in servers:
+        return "already_configured"
+    entry = f'[mcp_servers.leanwarp]\ncommand = {json.dumps(_command())}\nargs = ["mcp"]\n'
+    if text:
+        entry = ("\n" if text.endswith("\n") else "\n\n") + entry
+    # Write only a config that still reads, with exactly the entry added.
+    updated = _codex_servers(text + entry)
+    if updated is None or set(updated) != set(servers) | {"leanwarp"}:
+        return "unreadable_config"
+    config.write_text(text + entry, encoding="utf-8")
+    return "configured"
+
+
+def _cursor_mcp(home: Path) -> str:
+    config = home / "mcp.json"
+    try:
+        document = json.loads(config.read_text(encoding="utf-8")) if config.exists() else {}
+    except ValueError:
+        return "unreadable_config"
+    servers = document.setdefault("mcpServers", {}) if isinstance(document, dict) else None
+    if not isinstance(servers, dict):
+        return "unreadable_config"
+    if "leanwarp" in servers:
+        return "already_configured"
+    servers["leanwarp"] = {
+        "command": _command(),
+        "args": ["--project", "${workspaceFolder}", "mcp"],
+    }
+    config.write_text(json.dumps(document, indent=2) + "\n", encoding="utf-8")
+    return "configured"
+
+
+def setup(
+    *,
+    agents: Sequence[AgentName] = (),
+    mcp: bool = True,
+    refresh: bool = False,
+    home: Path | None = None,
+    environ: dict[str, str] | None = None,
+    run: Run = _run,
+) -> dict[str, Any]:
+    """Set up each named agent, or every agent found. With `refresh`, only replace
+    skills that are already installed and leave MCP configuration alone."""
+    home = home or Path.home()
+    known = _agents(home, dict(os.environ if environ is None else environ))
+    results: list[dict[str, Any]] = []
+    for name in AGENTS:
+        agent = known[name]
+        named = name in agents
+        if agents and not named:
+            continue
+        installed = agent.skills is not None and (agent.skills / "leanwarp").is_dir()
+        if refresh and not installed:
+            continue
+        if not refresh and not named and name != "agents" and not agent.home.is_dir():
+            results.append({"agent": name, "status": "not_found"})
+            continue
+        result: dict[str, Any] = {"agent": name, "status": "ok"}
+        if agent.skills is not None:
+            result["skill"] = _install_skill(agent.skills)
+        if mcp and not refresh and name != "agents":
+            agent.home.mkdir(parents=True, exist_ok=True)
+            if name == "claude-code":
+                result["mcp"] = _claude_mcp(home, run)
+            elif name == "codex":
+                result["mcp"] = _codex_mcp(agent.home)
+            else:
+                result["mcp"] = _cursor_mcp(agent.home)
+        results.append(result)
+    return {"agents": results}

leanwarp_cloud/amounts.py

@@ -0,0 +1,20 @@
+"""Exact workspace spending limits shared by Python, CLI and MCP."""
+
+from __future__ import annotations
+
+import re
+
+
+def validate_spending_cap(value: int | None) -> None:
+    if value is not None and (type(value) is not int or not 0 <= value <= 10**12):
+        raise ValueError("max_spend_microusd must be an integer from 0 to 1000000000000, or None")
+
+
+def usd_spending_cap(value: str) -> int:
+    """Parse decimal USD without floating-point rounding or silent precision loss."""
+    match = re.fullmatch(r"(0|[1-9][0-9]{0,6})(?:\.([0-9]{1,6}))?", value.strip())
+    if match is None:
+        raise ValueError("enter a USD amount from 0 to 1000000 with up to six decimals")
+    result = int(match[1]) * 1_000_000 + int((match[2] or "").ljust(6, "0"))
+    validate_spending_cap(result)
+    return result