mammoth-cli 2.2.12__tar.gz → 2.2.13__tar.gz

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.12
+Version: 2.2.13
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.12
 Requires-Dist: jsonschema>=4.20
 Requires-Dist: keyring<26,>=25.7
-Requires-Dist: mammoth-io<0.9,>=0.8.12
+Requires-Dist: mammoth-io<0.9,>=0.8.13
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/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.2.12"
+__version__ = "2.2.13"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -878,11 +878,11 @@ Status on release: ran once on CLI 2.0.14 — write sweep 2026-09-18: exit 0 on
 
 Run: `mammoth view update`. Exact input fields: `mammoth schema get view.update`.
 
-Example: `mammoth view update 123 123 --input '{"patch_data": [{"sample_key": "Status"}]}'`. Discovery only: this command is fail-closed and must not dispatch a request.
+Example: `mammoth view update 123 123 --input '{"name": "Revenue report"}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
 
-Execution is unavailable for the current contract and returns `unsupported_contract`. Do not infer request fields or retry it; use only a separately typed alternative.
+Result: `ViewUpdateResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
 
-Known restriction: BLOCKED[B09 DATAVIEW_INPUT_UNTYPED]: patch_data is an arbitrary dictionary; reserved, not registered.
+Status on release: untried; no live run recorded.
 
 ### `view.version.apply`
 

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/commands/schedule.py

@@ -22,6 +22,7 @@ from mammoth_cli.errors.envelope import (
     CODE_SDK_SYMBOL_UNRESOLVED,
     EXIT_USAGE,
     CliError,
+    not_available_error,
 )
 from mammoth_cli.manifest.loader import command_by_id
 from mammoth_cli.runtime.confirm import (
@@ -154,14 +155,17 @@ def _meta(invocation: Invocation, workspace_id: int, project_id: int) -> dict[st
 
 
 def schedule_list(invocation: Invocation) -> HandlerResult:
-    """List schedules in the active project. ``limit``/``offset`` are optional."""
-    project_id = require_project(invocation)
-    document = _bound_document(invocation)
-    kwargs: dict[str, Any] = {"project_id": project_id}
-    _forward_optional(document, kwargs, ("limit", "offset"))
-    with open_service(invocation) as (service, auth):
-        data = service.call(_symbol(invocation), **kwargs)
-    return data, _meta(invocation, auth.workspace_id, project_id)
+    """Retired: the server does not implement listing a project's schedules.
+
+    ``GET /workspaces/{id}/projects/{id}/schedules`` always answers ``5GENR011
+    NOT_IMPLEMENTED`` (the server raises it on purpose). The command stays so a
+    caller gets a clear answer instead of a bare backend error.
+    """
+    raise not_available_error(
+        "schedule list",
+        web_path="the web app, which opens a schedule from the dataset or automation that owns it",
+        instead="`schedule get SCHEDULE_ID` reads one schedule by an id you already have.",
+    )
 
 
 def schedule_get(invocation: Invocation) -> HandlerResult:

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/commands/schema.py

@@ -74,6 +74,7 @@ _GROUP_DISCOVERY_PURPOSES = {
 }
 
 _COMMAND_DISCOVERY_PURPOSES = {
+    "view.update": "rename change name to a new name title relabel",
     "file.upload": (
         "upload import CSV spreadsheet XLSX source data append add rows union stack "
         "a file into an existing dataset excel workbook tabs sheets drop in"
@@ -305,7 +306,7 @@ _COMMAND_DISCOVERY_PURPOSES = {
     "view.data.explore": (
         "explore trend trends trending over time per day week month quarter year by date "
         "distribution spread histogram top most common frequent values breakdown share "
-        "percentage profile"
+        "percentage profile period year quarter month date range coverage figure"
     ),
     # "Give the West team their own copy they can change" / "duplicate this
     # dataset as an independent copy" / "clone it without changing the
@@ -323,7 +324,10 @@ _COMMAND_DISCOVERY_PURPOSES = {
     # value -- and neither can be dropped as a data word anyway, since
     # view.data.explore's own purpose text already uses both for its trend
     # feature.
-    "view.data.aggregate": "group and sum totals by month week without changing the pipeline",
+    "view.data.aggregate": (
+        "group and sum totals by month week without changing the pipeline "
+        "sum total figure answer a question, read only"
+    ),
     # Goals stated as "what is in this data" / "why do customers churn": one
     # whole-view profile answers both, so the phrasing must reach it.
     "view.data.profile": (
@@ -1740,6 +1744,21 @@ def _inline_call_detail(entries: list[dict[str, Any]]) -> None:
             entry["agent_example"] = record["agent_example"]
 
 
+def _inline_picks(page: list[dict[str, Any]], offset: int) -> list[dict[str, Any]]:
+    """The entries to inline: the top ones, plus read commands ranked below a write.
+
+    A read that answers the question is worth its fields even when a write such as
+    ``view.transform.pivot`` outranks it; otherwise the caller needs a ``schema get``.
+    """
+    head = page[: max(0, _INLINE_DETAIL_COUNT - offset)]
+    reads = [
+        entry
+        for entry in page[len(head) :]
+        if (command_by_id(entry["command_id"]) or {}).get("mutation_class") == "read"
+    ]
+    return head + reads[:_INLINE_DETAIL_COUNT]
+
+
 #: How to drill down from a find: a family's full command list, or every family.
 _BROWSE_NEXT = (
     "mammoth schema list FAMILY lists every command in a family; mammoth schema list "
@@ -1902,7 +1921,7 @@ def find_schemas(
     )
     total_matches = len(ranked_matches)
     page = [match for _, match in ranked_matches[offset : offset + bounded_limit]]
-    _inline_call_detail(page[: max(0, _INLINE_DETAIL_COUNT - offset)])
+    _inline_call_detail(_inline_picks(page, offset))
     has_more = offset + len(page) < total_matches
     continuation = (
         {

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/commands/view.py

@@ -899,19 +899,45 @@ def view_impact(invocation: Invocation) -> HandlerResult:
 
 
 def view_update(invocation: Invocation) -> HandlerResult:
-    """Reject free-form dataview patches until the API supplies typed variants."""
-    raise CliError(
+    """Rename a view from the name input field; any other patch is refused.
+
+    The dataview patch route leaves op, path and value unconstrained, so the only
+    typed change offered is the rename (``replace`` on ``name``).
+    """
+    project_id = require_project(invocation)
+    dataview_id = _require_int_positional_at(invocation, 0, "view id")
+    document = invocation.load_input() or {}
+    name = document.get("name")
+    # ``dataview_id`` is the VIEW_ID positional, bound into the document by the contract.
+    allowed = {"name", _DATASET_ID_FIELD, "dataview_id"}
+    if set(document) - allowed or not isinstance(name, str) or not name.strip():
+        raise _untyped_patch_error(invocation)
+    with open_service(invocation) as (service, auth):
+        dataset_id = _resolve_dataset_id(service, invocation, dataview_id, document)
+        data = service.call(
+            _symbol(invocation),
+            dataset_id=dataset_id,
+            dataview_id=dataview_id,
+            patch_data=[{"op": "replace", "path": "name", "value": name.strip()}],
+            project_id=project_id,
+        )
+    return data, _meta(invocation, auth.workspace_id, project_id)
+
+
+def _untyped_patch_error(invocation: Invocation) -> CliError:
+    """The refusal for a view patch that is not the typed rename."""
+    return CliError(
         code=CODE_UNSUPPORTED_CONTRACT,
         message="Raw dataview patch operations are not available through the CLI.",
         exit_status=EXIT_USAGE,
         hint=(
-            "The OpenAPI operation leaves op, path, and value unconstrained. "
-            "Use a separately typed view command when its schema covers the intended change."
+            "The OpenAPI operation leaves op, path, and value unconstrained. The typed "
+            'change is the rename: view update VIEW_ID --input \'{"name": "New name"}\'.'
         ),
         details={
             "command_id": invocation.command_id,
             "blocker": "B09 DATAVIEW_INPUT_UNTYPED",
-            "typed_alternatives": [],
+            "typed_alternatives": ['view update VIEW_ID --input \'{"name": "New name"}\''],
         },
         recovery_commands=[
             "mammoth schema find view",
@@ -1288,17 +1314,19 @@ def _relabel_and_check(
 ) -> Any:
     """Relabel a data page to display names and add ``column_warnings`` and ``duplicates``.
 
+    Only read-only data reads call this, so a dates-as-text finding carries no convert fix.
+
     The metadata read happens only when the page has rows and the caller has
     not read it already (one read serves both the names and the types).
     """
     rows = data.get(_ROWS_KEY) if isinstance(data, dict) else None
     if not isinstance(rows, list) or not rows:
         data = _relabel_columns(service, dataset_id, view_id, project_id, data, mapping)
-        return _with_column_warnings(data, types or {}, view_id, dataset_id)
+        return _with_column_warnings(data, types or {}, view_id, dataset_id, read_only=True)
     if mapping is None or types is None:
         mapping, types = _column_profile(service, dataset_id, view_id, project_id)
     data = _relabel_columns(service, dataset_id, view_id, project_id, data, mapping)
-    data = _with_column_warnings(data, types, view_id, dataset_id)
+    data = _with_column_warnings(data, types, view_id, dataset_id, read_only=True)
     return _with_duplicates_fact(data, view_id, dataset_id, whole_view)
 
 
@@ -1322,7 +1350,11 @@ COLUMN_CHECK_ISSUES = (
 
 
 def _with_column_warnings(
-    data: Any, types: dict[str, str], view_id: int, dataset_id: int | None = None
+    data: Any,
+    types: dict[str, str],
+    view_id: int,
+    dataset_id: int | None = None,
+    read_only: bool = False,
 ) -> Any:
     """Add ``column_checks`` (always) and ``column_warnings`` (when found).
 
@@ -1332,13 +1364,19 @@ def _with_column_warnings(
     """
     if not isinstance(data, dict) or not isinstance(data.get(_ROWS_KEY, []), list):
         return data
-    checks, warnings = _check_columns(data.get(_ROWS_KEY) or [], types, view_id, dataset_id)
+    checks, warnings = _check_columns(
+        data.get(_ROWS_KEY) or [], types, view_id, dataset_id, read_only
+    )
     out = {**data, "column_checks": checks}
     return {**out, "column_warnings": warnings} if warnings else out
 
 
 def _check_columns(
-    rows: list[Any], types: dict[str, str], view_id: int, dataset_id: int | None
+    rows: list[Any],
+    types: dict[str, str],
+    view_id: int,
+    dataset_id: int | None,
+    read_only: bool = False,
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
     """Run ``column_warnings`` and describe what was checked (never raises)."""
     checks: dict[str, Any] = {
@@ -1350,7 +1388,7 @@ def _check_columns(
     warnings: list[dict[str, Any]] = []
     if rows and types:
         try:
-            warnings = column_warnings(rows, types, view_id, dataset_id)
+            warnings = column_warnings(rows, types, view_id, dataset_id, read_only)
         except Exception as exc:  # noqa: BLE001 -- a presentation aid must not fail the read
             checks["checked"] = []
             checks["error"] = f"{type(exc).__name__}: {exc}"
@@ -1728,7 +1766,7 @@ def _run_aggregate_for_compare(
 ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
     """Run ``view data aggregate``'s own handler against one view, for compare."""
     sub_invocation = dataclasses.replace(
-        invocation, command_id="view.data.aggregate", extra_args=[str(view_id)]
+        invocation, command_id="view.data.aggregate", extra_args=[str(view_id)], positionals={}
     )
     data, meta = view_data_aggregate(sub_invocation)
     rows = data.get(_ROWS_KEY, [])

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/runtime/dryrun_targets.py

@@ -192,6 +192,17 @@ SUBS: dict[str, tuple[Sub, ...]] = {
     "view.draft.discard": (
         Sub("draft", "view_id", "view", "view_id", name_fmt="{parent} › unsaved draft changes"),
     ),
+    "agent.action.delete": (
+        Sub(
+            "agent action",
+            "action_id",
+            source="agent.action.list",
+            container="actions",
+            forward=("session_id",),
+            label_paths=("name", "kind"),
+            name_fmt="what agent action {action_id} made: {label}",
+        ),
+    ),
     "agent.session.delete": (
         Sub(
             "agent session",
@@ -251,6 +262,34 @@ SUBS: dict[str, tuple[Sub, ...]] = {
             label_paths=("title", "name", "label"),
         ),
     ),
+    "dashboard.template.thumbnail.clear": (
+        Sub(
+            "dashboard template picture",
+            "template_id",
+            source="dashboard.template.get",
+            label_paths=("title", "name", "label"),
+            name_fmt="picture of dashboard template {label}",
+        ),
+    ),
+    "support.template.discard": (
+        Sub(
+            "curated template",
+            "slug",
+            source="support.template.list",
+            container="templates",
+            id_field="slug",
+            label_paths=("title", "slug"),
+        ),
+    ),
+    "workflow.cleanup": (
+        Sub(
+            "ghost workflows",
+            "project_id",
+            "project",
+            "project_id",
+            name_fmt="ghost (orphaned skeleton) workflows in {parent}",
+        ),
+    ),
     "template.delete": (
         Sub("template", "template_id", source="template.get", label_paths=("name", "title")),
     ),
@@ -328,6 +367,7 @@ COMMAND_TARGETS: dict[str, tuple[str, str]] = {
     "dataset.delete": ("dataset", "dataset_id"),
     "dataset.bulk-delete": ("dataset", "dataset_ids"),
     "dataset.file-settings.undo": ("dataset", "dataset_id"),
+    "dataset.broken-rows.resolve": ("dataset", "dataset_id"),
     "view.delete": ("view", "view_id"),
     "view.bulk-delete": ("view", "dataview_ids"),
     "batch.delete": ("batch", "batch_id"),
@@ -352,6 +392,10 @@ COMMAND_TARGETS: dict[str, tuple[str, str]] = {
 }
 
 
+#: Commands that make a new resource and change no existing one: nothing to name.
+CREATES_ONLY: frozenset[str] = frozenset({"dataset.create", "dataset.create-from-pdf"})
+
+
 def unresolvable_error(command_id: str, reason: str) -> CliError:
     """The fail-loud error for a command whose targets cannot be named."""
     return CliError(
@@ -496,6 +540,16 @@ def _unresolved_name(kind: str, target_id: object, symbol: str, key: str) -> Cli
     )
 
 
+def _container_items(listed: Any, container: str) -> list[Any]:
+    """The items of a list read: a bare list, a mapping, or a typed SDK model."""
+    if isinstance(listed, list):
+        return listed
+    held = (
+        listed.get(container) if isinstance(listed, Mapping) else getattr(listed, container, None)
+    )
+    return held if isinstance(held, list) else []
+
+
 def _sub_record(
     service: MammothService,
     sub: Sub,
@@ -516,7 +570,7 @@ def _sub_record(
     if symbol not in lists:
         lists[symbol] = service.call(symbol, **kwargs)
     listed = lists[symbol]
-    items = listed if isinstance(listed, list) else (listed or {}).get(sub.container, [])
+    items = _container_items(listed, sub.container)
     found = next((i for i in items if str(_path(i, sub.id_field)) == str(target)), None)
     if found is None:
         raise _unresolved_name(sub.kind, target, symbol, sub.id_field)
@@ -568,6 +622,8 @@ def _target_spec(command_id: str, would_call: Mapping[str, Any]) -> tuple[str, s
     """
     if command_id in COMMAND_TARGETS:
         return COMMAND_TARGETS[command_id]
+    if command_id in CREATES_ONLY:
+        return None
     record = command_by_id(command_id) or {}
     if record.get("mutation_class") == "destructive":
         raise unresolvable_error(command_id, "no read command names this command's targets")
@@ -589,6 +645,31 @@ def _remove_batch_invites(
     return _sub_targets(service, command_id, _INVITE_SUB, {"invite_ids": invite_ids})
 
 
+def _patched_dataset_ids(patch_data: Any) -> list[int]:
+    """The dataset ids a bulk patch renames: the keys of each operation's ``value``."""
+    operations = patch_data if isinstance(patch_data, list) else [patch_data]
+    found: list[int] = []
+    for operation in operations:
+        value = operation.get("value") if isinstance(operation, Mapping) else None
+        if isinstance(value, Mapping):
+            found.extend(int(key) for key in value if str(key).isdigit())
+    return list(dict.fromkeys(found))
+
+
+def _bulk_update_targets(
+    service: MammothService, command_id: str, arguments: Mapping[str, Any]
+) -> list[dict[str, Any]]:
+    """Name the datasets a ``dataset bulk-update`` patch changes, from its own ``patch_data``."""
+    ids = _patched_dataset_ids(arguments.get("patch_data"))
+    if not ids:
+        raise unresolvable_error(
+            command_id,
+            "'patch_data' names no dataset; pass "
+            '{"op": "replace", "path": "name", "value": {"<dataset_id>": "<new name>"}}',
+        )
+    return _read_names(service, "dataset", ids, arguments)
+
+
 def resolve_targets(
     service: MammothService, command_id: str, would_call: Mapping[str, Any]
 ) -> list[dict[str, Any]]:
@@ -611,6 +692,8 @@ def resolve_targets(
     arguments = would_call.get("arguments") or {}
     if command_id == "user.avatar.delete":
         return _avatar_target(service)
+    if command_id == "dataset.bulk-update":
+        return _bulk_update_targets(service, command_id, arguments)
     if command_id in SUBS:
         scope = {k: v for k, v in would_call.items() if k in ("view_id", "dataset_id")}
         merged = {**scope, **arguments}

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/services/command_contract.py

@@ -697,6 +697,9 @@ _S7_ADDITIONAL_INPUT_FIELDS: dict[str, tuple[FieldSpec, ...]] = {
         FieldSpec("activities", required=False, annotation=list[Any] | None, default=None),
         FieldSpec("user_ids", required=False, annotation=list[Any] | None, default=None),
     ),
+    # The typed rename: the handler builds the one ``replace`` on ``name``; the
+    # SDK's free-form ``patch_data`` is handler-owned and never offered.
+    "view.update": (FieldSpec("name", required=True, annotation=str),),
     "user.preference.update": (
         # PreferencesPatchRequest: replace ops on dotted paths rooted at
         # GLOBAL or WORKSPACE_PREFERENCES.

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/services/data_quality.py

@@ -354,6 +354,7 @@ def column_warnings(
     column_types: Mapping[str, str],
     view_id: int | None = None,
     dataset_id: int | None = None,
+    read_only: bool = False,
 ) -> list[dict[str, Any]]:
     """Return warnings for text columns that hold numbers or dates, and for blanks.
 
@@ -363,6 +364,8 @@ def column_warnings(
         view_id: The view the rows came from, used in the suggested command.
         dataset_id: The view's dataset, used for the duplicate-rows fix
             command (a mutation, so it needs the exact parent, not discovery).
+        read_only: The rows came from a read-only data read; a ``dates_stored_as_text``
+            finding then carries no ``fix``, since a read answers from the text as it is.
 
     Returns:
         One record per finding: ``column``, ``issue``
@@ -414,15 +417,10 @@ def column_warnings(
                         # there would be untrue.
                         detail += " (the conversion makes them empty)"
                     detail += "."
-                warnings.append(
-                    {
-                        "column": column,
-                        "issue": issue,
-                        "detail": detail,
-                        "fix": _convert_hint(view_id, column, to),
-                        "rows_checked": checked,
-                    }
-                )
+                finding: dict[str, Any] = {"column": column, "issue": issue, "detail": detail}
+                if not (read_only and kind == "dates"):
+                    finding["fix"] = _convert_hint(view_id, column, to)
+                warnings.append({**finding, "rows_checked": checked})
                 break
             variant_warning = _variant_spellings_warning(column, texts, view_id, checked)
             if variant_warning is not None:

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/services/input_fields.py

@@ -46,6 +46,8 @@ _HANDLER_OWNED_FIELDS: dict[str, frozenset[str]] = {
     # ``sort`` is the backend's internal result-column pairs; the CLI takes
     # ``order_by`` (result labels) and maps it, so a raw ``sort`` would be dropped.
     "view.data.aggregate": frozenset({"sort"}),
+    # ``view update`` offers only the typed rename; the handler builds the patch.
+    "view.update": frozenset({"patch_data"}),
 }
 
 # CLI-only commands whose complete request is carried by positionals/context.
@@ -76,6 +78,7 @@ _EXAMPLE_INPUT_HINTS: dict[str, dict[str, Any]] = {
     },
     # View display settings: real column names read better than sample keys.
     "view.transform.rename-columns": {"renames": {"cust_id": "Customer ID"}},
+    "view.update": {"name": "Revenue report"},
     "view.transform.sort": {"order_by": [["Revenue", "DESC"]]},
     # The backend requires integer resource ids ("resource_ids must be
     # comma-separated integers"); the SDK annotation is a plain list[str].

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/mammoth_cli/services/listing.py

@@ -352,14 +352,18 @@ def compact_view_list(
     Sizes and columns come from the records already fetched. Each kept view then
     gets ``sample_values`` from the backend's stored column stats via ``read_stats``
     (one stored-stats read per kept view, run concurrently; no query runs).
+    A list of one dataset's views names every column; several datasets cap it at a few.
     Returns ``{"dataviews", "shown"}`` plus
     ``first_dropped_dataset`` / ``views_omitted`` when something was cut, for the
     caller to turn into a way to the next page.
     """
     groups: dict[Any, list[tuple[dict[str, Any], dict[str, Any]]]] = {}
-    for ds_id, group in _group_by_dataset(views).items():
+    by_dataset = _group_by_dataset(views)
+    # One dataset's views are listed to be read from: the whole column list saves a `view get`.
+    every_column = all_columns or len(by_dataset) == 1
+    for ds_id, group in by_dataset.items():
         groups[ds_id] = [
-            (v, view_summary(v, datasets.get(ds_id), ds_id, all_columns)) for v in group
+            (v, view_summary(v, datasets.get(ds_id), ds_id, every_column)) for v in group
         ]
     chosen, dropped_dataset, omitted = _choose_views(groups)
     with ThreadPoolExecutor(max_workers=_STATS_WORKERS) as pool:

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.12"
+version = "2.2.13"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"
 license = "LicenseRef-Proprietary"
 requires-python = ">=3.12,<3.15"
 dependencies = [
-    "mammoth-io (>=0.8.12,<0.9)",
+    "mammoth-io (>=0.8.13,<0.9)",
     "typer (>=0.27,<0.28)",
     "rich (>=15,<16)",
     "platformdirs (>=4.10,<5)",

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/spec/manifests/commands/schedule.yaml

@@ -158,7 +158,7 @@ commands:
   - CT-SCHEDULE-LIST-ERROR
   draft_test: null
   undo_test: null
-  known_restrictions: 'B04 SERVER_VARIANCE: unconditionally unimplemented on every backend
+  known_restrictions: 'Retired: the command answers not_available and names the web app. B04 SERVER_VARIANCE: unconditionally unimplemented on every backend
     release tested, not intermittent -- GET .../schedules always returns HTTP 400 with error
     code 5GENR011 NOT_IMPLEMENTED (mvc-service apiv2/apiv2/schedules/controller.py
     ScheduleController.list_schedules always raises ClientError(not_implemented_error); its

{mammoth_cli-2.2.12 → mammoth_cli-2.2.13}/spec/manifests/commands/view.yaml

@@ -5834,7 +5834,7 @@ commands:
   required_fixture_guard: null
   secret_fields: []
   human_example: mammoth view update VIEW_ID --help
-  agent_example: 'mammoth view update 123 123 --input ''{"patch_data": [{"sample_key": "Status"}]}'''
+  agent_example: 'mammoth view update 123 123 --input ''{"name": "Revenue report"}'''
   unit_tests:
   - UT-VIEW-UPDATE
   contract_tests:
@@ -5843,8 +5843,8 @@ commands:
   - CT-VIEW-UPDATE-ERROR
   draft_test: null
   undo_test: null
-  known_restrictions: 'BLOCKED[B09 DATAVIEW_INPUT_UNTYPED]: patch_data is an arbitrary dictionary; reserved,
-    not registered.'
+  known_restrictions: 'Only the typed rename is offered (--input {"name": ...}); any other patch is refused
+    with B09 DATAVIEW_INPUT_UNTYPED because patch_data is an arbitrary dictionary.'
   reviewed_by: primary
 - command_id: view.version.apply
   command_path: view version apply