mammoth-cli 2.0.18__tar.gz → 2.0.19__tar.gz

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.0.18
+Version: 2.0.19
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -217,6 +217,12 @@ mammoth skill install --input '{"agents": ["codex"], "scope": "project"}'
 Use `mammoth skill update` after a CLI upgrade. It refreshes copies owned by the
 installer and reports modified copies instead of silently replacing them.
 
+The CLI checks PyPI for a newer release at most once a day, after a command
+has finished: every JSON envelope carries `meta.update_available` and human
+output adds one stderr line. Set `MAMMOTH_NO_UPDATE_CHECK=1` to turn it off,
+or `MAMMOTH_AUTO_UPGRADE=1` to have it upgrade itself (opt-in; see
+[Upgrade](https://github.com/EdgeMetric/mammothsdk/blob/main/mammoth-cli/docs/upgrade.md)).
+
 ## What you can do
 
 | Area | Command families |

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/README.md

@@ -189,6 +189,12 @@ mammoth skill install --input '{"agents": ["codex"], "scope": "project"}'
 Use `mammoth skill update` after a CLI upgrade. It refreshes copies owned by the
 installer and reports modified copies instead of silently replacing them.
 
+The CLI checks PyPI for a newer release at most once a day, after a command
+has finished: every JSON envelope carries `meta.update_available` and human
+output adds one stderr line. Set `MAMMOTH_NO_UPDATE_CHECK=1` to turn it off,
+or `MAMMOTH_AUTO_UPGRADE=1` to have it upgrade itself (opt-in; see
+[Upgrade](https://github.com/EdgeMetric/mammothsdk/blob/main/mammoth-cli/docs/upgrade.md)).
+
 ## What you can do
 
 | Area | Command families |

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/__init__.py

@@ -6,7 +6,7 @@ not implement a second HTTP client and does not call private SDK members.
 
 from __future__ import annotations
 
-__version__ = "2.0.18"
+__version__ = "2.0.19"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.0.18
+version: 2.0.19
 description: "Use Mammoth Analytics from a terminal: install or authenticate the CLI, discover its live command contract, and safely manage projects, data, views, pipelines, dashboards, exports, and handoffs."
 ---
 

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/capabilities.md

@@ -1,7 +1,7 @@
 # What is proven on release
 
 Generated from `docs/release-capability-matrix.json`; do not edit by hand.
-The CLI publishes 551 commands. 455 of them bind one of the 528 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (every `view transform *` command submits through `view.task.add`). 258 bound commands ran once successfully on release, 2 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID --output json --no-input`, run it, and treat the structured error envelope as the answer.
+The CLI publishes 552 commands. 455 of them bind one of the 528 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (every `view transform *` command submits through `view.task.add`). 258 bound commands ran once successfully on release, 2 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID --output json --no-input`, run it, and treat the structured error envelope as the answer.
 
 Status meanings:
 

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/command-index.md

@@ -1,6 +1,6 @@
 # Published CLI command catalog
 
-This generated catalog is a lookup table for every command in the published CLI manifest, currently 551; each entry carries its release status line. It is a command-contract index, not an assertion that every backend/OpenAPI operation has a CLI binding. For an exact local CLI contract, run `mammoth schema get COMMAND_ID --output json --no-input`; `mammoth capability list` is an API-binding inventory and can omit typed/local CLI routes. For focused workflows, read the [recipes index](recipes/index.md). Sensitive structured input must come from a private file or pipe; never put secrets in literal argv.
+This generated catalog is a lookup table for every command in the published CLI manifest, currently 552; each entry carries its release status line. It is a command-contract index, not an assertion that every backend/OpenAPI operation has a CLI binding. For an exact local CLI contract, run `mammoth schema get COMMAND_ID --output json --no-input`; `mammoth capability list` is an API-binding inventory and can omit typed/local CLI routes. For focused workflows, read the [recipes index](recipes/index.md). Sensitive structured input must come from a private file or pipe; never put secrets in literal argv.
 
 Load only the applicable domain file:
 
@@ -31,7 +31,7 @@ Load only the applicable domain file:
 - [log](commands/log.md) — 2 published commands
 - [notification](commands/notification.md) — 5 published commands
 - [parameter](commands/parameter.md) — 14 published commands
-- [project](commands/project.md) — 18 published commands
+- [project](commands/project.md) — 19 published commands
 - [report](commands/report.md) — 1 published commands
 - [schedule](commands/schedule.md) — 5 published commands
 - [schema](commands/schema.md) — 3 published commands

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/project.md

@@ -62,6 +62,16 @@ Result: `ProjectDeleteResult`; mutation `high_impact`, confirmation `confirm_tar
 
 Status on release: ran once on CLI 2.0.18 — fixture-lifecycle sweep 2026-09-19: exit 0 on release with CLI 2.0.18. Deleted project 41 (sweep-218-1224), read back with project get 41 beforehand. Single invocation only.
 
+### `project.ensure`
+
+Run: `mammoth project ensure`. Exact input fields: `mammoth schema get project.ensure --output json --no-input`.
+
+Example: `mammoth project ensure 'Revenue report' --output json --no-input`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ProjectEnsureResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `project.get`
 
 Run: `mammoth project get`. Exact input fields: `mammoth schema get project.get --output json --no-input`.

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -66,7 +66,7 @@ Status on release: ran once on CLI 2.0.14 — write sweep 2026-09-18: exit 0 on
 
 Run: `mammoth view checkpoint create`. Exact input fields: `mammoth schema get view.checkpoint.create --output json --no-input`.
 
-Example: `mammoth view checkpoint create 123 123 --input '{"body": {"checkpoint_name": "Revenue report", "checkpoint_type": "alert"}}' --output json --no-input`. Placeholders are illustrative; resolve IDs and input from observed reads.
+Example: `mammoth view checkpoint create 123 123 --input '{"body": {"checkpoint_name": "Revenue report", "checkpoint_type": "alert", "pinned_to_end": true}}' --output json --no-input`. Placeholders are illustrative; resolve IDs and input from observed reads.
 
 Result: `ViewCheckpointCreateResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
 

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/machine-output.md

@@ -2,9 +2,13 @@
 
 ## Success envelope (stdout)
 ```json
-{"schema_version": 1, "data": <result>, "meta": {"command": "project list", "profile": "default", "workspace_id": 4, "project_id": 180, "pagination": null}}
+{"schema_version": 1, "data": <result>, "meta": {"command": "project list", "profile": "default", "workspace_id": 4, "project_id": 180, "pagination": null, "update_available": null}}
 ```
 
+`meta.update_available` is `null` or `{"current", "latest", "command"}` when a
+newer CLI is on PyPI (checked once a day, after a command, never blocking).
+Run its `command` before starting a task, not in the middle of one.
+
 ## Error envelope (stderr)
 ```json
 {"schema_version": 1, "error": {"code": "resource_not_found", "message": "...", "hint": "...", "details": {}, "request_id": null, "retryable": false, "authorization_required": false, "recovery_commands": ["..."], "log_ref": {"file": ".../logs/2026-09-19.jsonl", "run_id": "b6bc6bf6d166"}}}

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/end-to-end.md

@@ -11,7 +11,7 @@ mammoth doctor --output json --no-input                # must succeed
 mammoth project list --output json --no-input          # baseline: ids that exist before you start
 
 # 1. own project, upload, find the view ids
-mammoth project create 'orders-etl' --output json --no-input                 # -> PROJECT_ID
+mammoth project ensure 'From Claude' --output json --no-input                # -> PROJECT_ID (data.project_id; reused next time)
 mammoth file upload orders.csv --project PROJECT_ID --output json --no-input # -> data.datasets[].id/status
 mammoth file upload customers.csv --project PROJECT_ID --output json --no-input
 # a dataset in need_action is not usable yet: follow need-action.md (file-settings update), then re-read

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/resources.md

@@ -6,11 +6,30 @@ id instead. Run `view list DATASET_ID --project PROJECT_ID` to get it. Do not
 dig through `dataset get` and its `dependencies` field for a view id; `view
 list` is the supported route.
 
-Discover exact contracts, then upload and read back explicit parents. A new
-project takes its name as the positional argument:
+Discover exact contracts, then upload and read back explicit parents.
+
+## Where uploads land
+
+Unless the task names a project, work in one project of your own and put
+every dataset of the task there, so the user's real projects stay clean and
+one sweep removes everything. `project ensure` is idempotent get-or-create
+by exact name: re-running it (or a second task) returns the same id
+(`created: false`) instead of making another project. A one-off task can
+still use `project create NAME` for a throwaway project.
+
+```bash
+mammoth project ensure 'From Claude' --output json --no-input   # -> data.project_id, data.created
+mammoth project ensure 'From Claude' --output json --no-input   # same id again, created: false
+```
+
+Moving a dataset between projects is not a single API call on release;
+re-upload into the target project when the task asks for that. To sweep the
+working project when the task says it was temporary, delete it (one id per
+call, read back) with `project delete ID --yes --confirm ID`; otherwise delete
+only the datasets you created and leave the project for the next task.
 
 ```bash
-mammoth project create 'PROJECT NAME' --output json --no-input
+mammoth project ensure 'PROJECT NAME' --output json --no-input
 mammoth schema get file.upload --output json --no-input
 mammoth file upload ./SOURCE.csv --project PROJECT_ID --output json --no-input
 mammoth dataset list --project PROJECT_ID --output json --no-input
@@ -18,8 +37,31 @@ mammoth view list DATASET_ID --project PROJECT_ID --output json --no-input
 mammoth view get VIEW_ID --project PROJECT_ID --output json --no-input
 ```
 
+## What `file upload` accepts
+
+`file upload` reads the file from local disk and streams it; nothing passes
+through your context, so size costs nothing but time. Two boundaries hold:
+
+- Format, by extension: `csv tsv psv txt xls xlsx xml pdf tiff jpeg jpg png
+  heic webp`, or an archive of those (`zip gz bz2 tar 7z`). `.json` is not
+  accepted; convert to CSV first. Other extensions fail before any upload.
+- Size, at the ingress in front of the API: a 60 MB upload is refused with
+  HTTP 413 (`invalid_argument`, "larger than Mammoth accepts") before the API
+  sees it; 16 MB is accepted. The exact cap between those was not pinned
+  down. Keep one upload well under 16 MB: split a larger file by rows and
+  upload the parts, or compress it (a `.zip`/`.gz` of a CSV is accepted and
+  expanded server-side).
+
+Scanning and parsing time grows with size; pass `--timeout 300` on anything
+past a few MB and, when the command returns `timeout` with a `job_handle`,
+poll with the `job get` recovery command it prints instead of uploading
+again. A bare HTTP 500 from this route (`outcome_unknown`, empty body) means
+the upload service is degraded; check `job get` for a job first, do not
+retry in a loop.
+
 `file upload` takes the local path as its positional argument; there is no
-`--source`/`--file` option. Its result carries the status the platform holds
+`--source`/`--file` option. A path that does not exist is a usage error
+(`Local file not found`) before any request. Its result carries the status the platform holds
 for each created dataset: `ready`, or `need_action` with a `next_command`, in
 which case follow [need-action](need-action.md) before looking for a view. `dataset delete` is asynchronous: re-read
 `dataset list` (the id disappears once the job completes) before reporting.

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/transforms.md

@@ -89,6 +89,12 @@ but the copy answers every read with `4DTVW019` and its copied tasks never
 execute. A plain `view create DATASET_ID` (no `clone_from`) gives a fresh view
 of the raw upload, without the pipeline:
 
+Every pivot `as_name` must be a display name that does not already exist on
+the view (`4DTVW018 Same display name cannot be reused`): to carry a joined
+column such as `monthly_target` into the summary, aggregate it under a new
+name (`{"column": "monthly_target", "function": "MAX", "as_name": "target"}`)
+or use the SQL task with `MAX(monthly_target) AS monthly_target`.
+
 ```bash
 mammoth schema get view.transform.pivot --output json --no-input
 mammoth view transform add-sql VIEW_ID --project PROJECT_ID \

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/bundled_skill/mammoth-cli/references/task-start.md

@@ -16,7 +16,9 @@ or secrets in an argument, prompt, transcript, or checkpoint.
    Pin `mammoth-cli==X.Y.Z` when the task names an approved release. Use the
    host installer script (`installers/mammoth-install.sh` in the repository)
    only when the operator names it; do not pipe a remote script to a shell on
-   your own initiative. The SDK (`mammoth-io`) comes with the CLI.
+   your own initiative. The SDK (`mammoth-io`) comes with the CLI. If a later
+   envelope shows `meta.update_available`, run the `command` it names before
+   the next task step, then continue on the new version.
 2. Locate the installed guidance with `mammoth skill path --output json
    --no-input` and read `SKILL.md`; open a reference only when the routing
    table sends you there. `references/commands/*.md` are per-command lookups,

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/commands/doctor.py

@@ -20,7 +20,7 @@ from mammoth_cli import __version__
 from mammoth_cli.context import credentials, profiles
 from mammoth_cli.context.resolver import resolve_auth
 from mammoth_cli.errors.envelope import CliError
-from mammoth_cli.runtime import runlog
+from mammoth_cli.runtime import runlog, updates
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.session import open_service, resolved_project
 
@@ -57,15 +57,13 @@ def _safe_connection_diagnostics(error: CliError, *, debug: bool) -> dict[str, A
     if isinstance(retry_after, str):
         if len(retry_after) > 10 or not retry_after.isascii() or not retry_after.isdigit():
             retry_after = None
-    elif (
-        not isinstance(retry_after, int)
-        or isinstance(retry_after, bool)
-        or retry_after < 0
-    ):
+    elif not isinstance(retry_after, int) or isinstance(retry_after, bool) or retry_after < 0:
         retry_after = None
     request_id = error.request_id or raw.get("request_id")
-    if not isinstance(request_id, str) or len(request_id) > 128 or not re.fullmatch(
-        r"[A-Za-z0-9._:-]+", request_id
+    if (
+        not isinstance(request_id, str)
+        or len(request_id) > 128
+        or not re.fullmatch(r"[A-Za-z0-9._:-]+", request_id)
     ):
         request_id = None
 
@@ -166,6 +164,16 @@ def doctor(invocation: Invocation) -> HandlerResult:
         )
     )
 
+    latest = updates.latest_from_pypi()
+    if latest is None:
+        version_detail = f"{__version__} installed; PyPI not reachable to compare"
+    elif updates.is_newer(latest):
+        version_detail = f"{__version__} installed; {latest} available: {updates.UPGRADE_COMMAND}"
+    else:
+        version_detail = f"{__version__} installed; latest on PyPI"
+    # Informational: an older CLI still works, so the check never fails.
+    checks.append(_check("cli_version", True, version_detail))
+
     record = profiles.get_profile(profile_name)
     checks.append(
         _check(
@@ -266,9 +274,7 @@ def doctor(invocation: Invocation) -> HandlerResult:
         recommendations.append("mammoth context project use PROJECT_ID")
     if not connection_ok and auth_ok and not invocation.debug:
         debug_profile = f" --profile {shlex.quote(profile_name)}" if profile_name else ""
-        recommendations.append(
-            f"mammoth doctor --debug{debug_profile} --output json --no-input"
-        )
+        recommendations.append(f"mammoth doctor --debug{debug_profile} --output json --no-input")
 
     data = {
         "cli_version": __version__,

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/commands/file.py

@@ -12,6 +12,7 @@ SDK method named by the command's reviewed manifest ``sdk_symbol``.
 from __future__ import annotations
 
 from collections.abc import Callable
+from pathlib import Path
 from typing import Any
 
 from mammoth_cli.errors.envelope import (
@@ -213,6 +214,7 @@ def file_upload(invocation: Invocation) -> HandlerResult:
         document,
         **({"files": list(invocation.extra_args)} if invocation.extra_args else {}),
     )
+    _require_local_files(kwargs.get("files"))
     with open_service(invocation) as (service, auth):
         data = service.call(_symbol(invocation), **kwargs)
         # The SDK waits for the upload job and returns the created dataset
@@ -227,6 +229,31 @@ def file_upload(invocation: Invocation) -> HandlerResult:
     return result, _meta(invocation, auth.workspace_id, resolved_project(invocation))
 
 
+def _require_local_files(files: Any) -> None:
+    """Fail as a usage error, naming the path, when a local file is missing.
+
+    The SDK raises a bare ``ValueError`` for an unreadable path, which the
+    generic mapping renders as an opaque ``api_error``; a relative path from
+    the wrong working directory is the usual cause and must say so.
+    """
+    candidates = files if isinstance(files, list) else [files] if files else []
+    for candidate in candidates:
+        if not isinstance(candidate, str):
+            continue
+        path = Path(candidate).expanduser()
+        if not path.is_file():
+            raise CliError(
+                code=CODE_INVALID_ARGUMENT,
+                message=f"Local file not found: {candidate}",
+                exit_status=EXIT_USAGE,
+                hint=(
+                    f"Resolved against the working directory {Path.cwd()}; pass an absolute "
+                    "path or run the command from the directory that holds the file."
+                ),
+                details={"path": candidate, "cwd": str(Path.cwd())},
+            )
+
+
 _DATASET_GET_SYMBOL = "mammoth.api.datasets.DatasetsAPI.get"
 
 

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/commands/project.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 from typing import Any
 
 from mammoth_cli.errors.envelope import (
+    CODE_CONFLICT,
     CODE_INVALID_ARGUMENT,
     CODE_MISSING_ARGUMENT,
     CODE_MISSING_FIELD,
@@ -216,6 +217,76 @@ def project_create(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id, resolved_project(invocation))
 
 
+#: The projects route caps ``limit`` at 100 (backend 4GENR007 above it) and
+#: the SDK exposes no offset, so this is the largest listing one call can see.
+_ENSURE_PROJECT_LIST_LIMIT = 100
+_ENSURE_CREATE_SYMBOL = "mammoth.api.projects.ProjectsAPI.create"
+
+
+def project_ensure(invocation: Invocation) -> HandlerResult:
+    """Return the project with exactly this name, creating it when absent.
+
+    Idempotent get-or-create for a scratch or working project (the "From
+    Claude" convention: pick one project once, land every task's datasets
+    there, sweep it with ``project delete``). Matching is exact and
+    case-sensitive on the name; when several projects share the name the
+    lowest id wins and ``duplicates`` lists the rest, so a re-run never
+    creates a second one.
+    """
+    document = invocation.load_input() or {}
+    name = _string_positional(invocation) or document.get("name")
+    if not isinstance(name, str) or not name.strip():
+        raise CliError(
+            code=CODE_MISSING_ARGUMENT,
+            message="A project name is required.",
+            exit_status=EXIT_USAGE,
+            hint="Pass the name as a positional argument or a 'name' input field.",
+        )
+    with open_service(invocation) as (service, auth):
+        listing = service.list_projects(limit=_ENSURE_PROJECT_LIST_LIMIT)
+        projects = list(listing.get("projects", [])) if isinstance(listing, dict) else []
+        same_name = sorted(
+            (p for p in projects if isinstance(p, dict) and p.get("name") == name),
+            key=lambda p: int(p.get("id") or 0),
+        )
+        if same_name:
+            chosen = same_name[0]
+            data: dict[str, Any] = {
+                "project": chosen,
+                "project_id": chosen.get("id"),
+                "created": False,
+                "duplicates": [p.get("id") for p in same_name[1:]],
+            }
+            return data, _meta(invocation, auth.workspace_id, chosen.get("id"))
+        truncated = bool(listing.get("next")) if isinstance(listing, dict) else False
+        if truncated or len(projects) >= _ENSURE_PROJECT_LIST_LIMIT:
+            # A name beyond the first page may exist; creating blindly would
+            # break the idempotency this command promises.
+            raise CliError(
+                code=CODE_CONFLICT,
+                message=(
+                    f"Workspace has more than {_ENSURE_PROJECT_LIST_LIMIT} projects; "
+                    f"cannot prove {name!r} is absent."
+                ),
+                exit_status=EXIT_USAGE,
+                hint="Find the project with 'project list' and pass --project, "
+                "or create it explicitly with 'project create'.",
+                details={"listed": len(projects)},
+            )
+        created = service.call(_ENSURE_CREATE_SYMBOL, name=name)
+    record = created.get("project", created) if isinstance(created, dict) else {}
+    project_id = record.get("id") if isinstance(record, dict) else None
+    if project_id is None and isinstance(created, dict):
+        project_id = created.get("project_id") or created.get("id")
+    data = {
+        "project": record if isinstance(record, dict) else created,
+        "project_id": project_id,
+        "created": True,
+        "duplicates": [],
+    }
+    return data, _meta(invocation, auth.workspace_id, project_id)
+
+
 def project_update(invocation: Invocation) -> HandlerResult:
     """Update a project's name or color from the ``--input`` document."""
     project_id = _project_id(invocation)

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/commands/registry.py

@@ -187,6 +187,7 @@ HANDLERS: dict[str, Handler] = {
     "project.publish-credentials": project_cmd.project_publish_credentials,
     # project family (mutations)
     "project.create": project_cmd.project_create,
+    "project.ensure": project_cmd.project_ensure,
     "project.update": project_cmd.project_update,
     "project.delete": project_cmd.project_delete,
     "project.bulk-delete": project_cmd.project_bulk_delete,

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/commands/upgrade.py

@@ -166,9 +166,12 @@ def build_upgrade_command(manager: str, target_version: str | None) -> list[str]
     return [sys.executable, "-m", "pip", "install", "--upgrade", PACKAGE_NAME]
 
 
-def _run_upgrade(command: list[str]) -> subprocess.CompletedProcess[str]:
+def run_upgrade(command: list[str]) -> subprocess.CompletedProcess[str]:
     """Run the upgrade command as a subprocess, capturing its output.
 
+    Public so the opt-in automatic upgrade (:mod:`mammoth_cli.runtime.updates`)
+    goes through the same seam tests patch here.
+
     Raises:
         CliError: ``upgrade_failed`` when the command cannot be launched.
     """
@@ -269,7 +272,7 @@ def perform(invocation: Invocation, *, check: bool, target_version: str | None)
         policy=POLICY_PROMPT_OR_YES,
         action=f"upgrade {PACKAGE_NAME} to {action_target} using {manager}",
     )
-    result = _run_upgrade(command)
+    result = run_upgrade(command)
     if result.returncode != 0:
         raise CliError(
             code="upgrade_failed",

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/output/envelope.py

@@ -17,6 +17,9 @@ class Meta:
     workspace_id: int | None = None
     project_id: int | None = None
     pagination: dict[str, Any] | None = None
+    #: ``{"current", "latest", "command"}`` when a newer CLI is on PyPI
+    #: (from the daily cached check), else None.
+    update_available: dict[str, Any] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -25,6 +28,7 @@ class Meta:
             "workspace_id": self.workspace_id,
             "project_id": self.project_id,
             "pagination": self.pagination,
+            "update_available": self.update_available,
         }
 
 

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/runtime/executor.py

@@ -20,6 +20,7 @@ from mammoth_cli.errors.envelope import EXIT_USAGE, CliError
 from mammoth_cli.output.envelope import Meta, Result
 from mammoth_cli.output.policy import MACHINE_OUTPUTS, VALID_OUTPUTS
 from mammoth_cli.output.render import render
+from mammoth_cli.runtime import updates
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.runlog import RunLog
 from mammoth_cli.services.mapping import map_sdk_exception
@@ -73,6 +74,7 @@ def emit_success(
     workspace_id: int | None = None,
     project_id: int | None = None,
     pagination: dict[str, Any] | None = None,
+    update_available: dict[str, Any] | None = None,
 ) -> None:
     """Render one success envelope to stdout.
 
@@ -85,6 +87,7 @@ def emit_success(
         workspace_id: The resolved workspace id, if any.
         project_id: The resolved project id, if any.
         pagination: Pagination metadata, if any.
+        update_available: The cached newer-release notice, if any.
     """
     meta = Meta(
         command=command_id.replace(".", " "),
@@ -92,6 +95,7 @@ def emit_success(
         workspace_id=workspace_id,
         project_id=project_id,
         pagination=pagination,
+        update_available=update_available,
     )
     envelope = Result(data=data, meta=meta).to_envelope()
     render(envelope, output=output)
@@ -171,10 +175,15 @@ def run(
             run_log.finish(error.exit_status, error_code=error.code)
         emit_error(error, machine=machine_error, output=output)
 
+    # The update notice is read from the daily cache (no network); the cache
+    # itself is refreshed only after the command has produced its output.
+    update = updates.available_update(command_id)
     try:
         _validate_output(output)
+        updates.auto_upgrade(command_id, run_log)
         data, meta_extra = producer()
-        emit_success(command_id, data, output, **meta_extra)
+        emit_success(command_id, data, output, update_available=update, **meta_extra)
+        updates.emit_hint(update, output=output)
     except CliError as error:
         fail(error)
         raise typer.Exit(error.exit_status) from None
@@ -194,6 +203,7 @@ def run(
         raise typer.Exit(mapped_error.exit_status) from None
     if run_log is not None:
         run_log.finish(0)
+    updates.refresh_if_stale(command_id)
 
 
 def _open_run_log(command_id: str, invocation: Invocation | None) -> RunLog | None:

{mammoth_cli-2.0.18 → mammoth_cli-2.0.19}/mammoth_cli/runtime/strict.py

@@ -60,6 +60,7 @@ CODE_INVALID_INPUT_FIELD_TYPE = "invalid_input_field_type"
 _TRUE_STRINGS = frozenset({"true", "1", "yes", "y", "on"})
 _FALSE_STRINGS = frozenset({"false", "0", "no", "n", "off"})
 
+
 def _unknown_option_hint(command_id: str, token: str) -> tuple[str, dict[str, Any]]:
     """Name the accepted form when an unknown ``--option`` matches a real field.
 
@@ -138,8 +139,7 @@ def _invalid_field_type_error(command_id: str, field: str, value: Any, expected:
     return CliError(
         code=CODE_INVALID_INPUT_FIELD_TYPE,
         message=(
-            f"Input field '{field}' for '{command_id.replace('.', ' ')}' must be a "
-            f"{expected}."
+            f"Input field '{field}' for '{command_id.replace('.', ' ')}' must be a " f"{expected}."
         ),
         exit_status=EXIT_USAGE,
         hint=f"Pass '{field}' as a {expected} value.",
@@ -193,6 +193,30 @@ def _coerce_float(value: Any, *, command_id: str, field: str) -> float:
     raise _invalid_field_type_error(command_id, field, value, "number")
 
 
+def _relax_numeric_oneof(schema: Any) -> Any:
+    """Turn ``oneOf: [number, integer, ...]`` into ``anyOf`` throughout ``schema``.
+
+    The backend's generated schemas declare numeric fields (``threshold`` on a
+    data check, for one) as ``oneOf`` over ``number`` and ``integer``. An
+    integral value satisfies both branches, so strict ``oneOf`` rejects
+    exactly the values the backend accepts (``5`` fails, ``0.5`` passes).
+    The intent is clearly "any of these"; validate it that way.
+    """
+    if isinstance(schema, list):
+        return [_relax_numeric_oneof(item) for item in schema]
+    if not isinstance(schema, dict):
+        return schema
+    relaxed: dict[str, Any] = {}
+    for key, value in schema.items():
+        if key == "oneOf" and isinstance(value, list):
+            types = {b.get("type") for b in value if isinstance(b, dict)}
+            if {"number", "integer"} <= types:
+                relaxed["anyOf"] = _relax_numeric_oneof(value)
+                continue
+        relaxed[key] = _relax_numeric_oneof(value)
+    return relaxed
+
+
 def _coerce_document_fields(
     command_id: str,
     document: dict[str, Any],
@@ -208,15 +232,12 @@ def _coerce_document_fields(
             key == "body"
             and is_opaque_mapping(field.annotation)
             and input_schema is not None
-            and (
-                body_schema := input_schema.get("properties", {}).get("body")
-            )
-            is not None
+            and (body_schema := input_schema.get("properties", {}).get("body")) is not None
         ):
             from jsonschema import ValidationError, validate  # type: ignore[import-untyped]
 
             try:
-                validate(document[key], thaw_contract_metadata(body_schema))
+                validate(document[key], _relax_numeric_oneof(thaw_contract_metadata(body_schema)))
             except ValidationError as error:
                 path = ".".join(str(part) for part in error.absolute_path)
                 field_path = f"body.{path}" if path else "body"