---
title: "Source: schemas/management_api.json"
description: "Generated page for the indexed contract source schemas/management_api.json: its schema fields or contract text, and its published text."
slug: /reference/sources/schemas/management-api
order: 11
visibility: public
redirects_from: []
---

# Source: schemas/management\_api\.json

Generated automatically from the [published contract sources](/cloud/reference/about/#contract-sources).

Source path: schemas/management\_api\.json.

This source leaves out the rows and paragraphs that name an action only platform staff can call.

## Complete source

```json
{
  "title": "tzCloud — management API enumeration, contract version 1",
  "version": "2026-11-21.6",
  "description": "The one enumeration of the management plane's resources and actions (MAPI-01 in the management API contract). Actions carry their surface, `tzcloud`, `tztrack`, or `account`, from which a row's MCP name derives (MCP-08), their resource, tier, and — where restricted — the clients that may call them, plus the access marking where a row needs no acting identity and stands outside every grant's bound (MAPI-11), the switch marking where a row is admitted by a control-plane setting (MAPI-16), and the admits marking where a row, unmarked or grant-marked, is admitted to a token the named grant bounds (MAPI-16), and the listing marking where a row lists only to a credential holding `super_admin` or a grant its admits marking names (MCP-08); the MCP tools are these actions, name for name (MAPI-08). Each row's `owners` names the statements its summary and its arguments' descriptions follow, the summary and the descriptions carrying no identifier themselves (MCP-05); the generated contract reference omits the member. A test in the platform's suite holds the rows to the rules and the two enumerations to each other.",
  "contract_version": 1,
  "compatibility": {
    "_": "API-L0-16s two values, and the only place either is written. A superseded contract version, and a superseded operated-backend package contract version, each stay served for a window counted from the first customer release. window_days is 1826 — five years, at 365.25 days a year rounded down — set by the owner 2026-08-24 UTC. first_customer_release is null until the first customer release, which follows a beta period whose releases are owed no compatibility retention; while it is null the window binds nothing — no version has a window before any customer has shipped, so no deploy is refused for its version and no running client is told it is out of date. The enforcement that reads both members falls due when the date is set (API-L0-16).",
    "first_customer_release": null,
    "window_days": 1826
  },
  "resources": [
    {
      "name": "account",
      "summary": "The connected customer's account: identity, standing, and its estate's root.",
      "owners": [
        "ACB-L0-01"
      ]
    },
    {
      "name": "application",
      "summary": "One admitted application: its manifest, provenance tier, and environments.",
      "owners": [
        "PLD-L0-62",
        "PLD-L0-40"
      ]
    },
    {
      "name": "environment",
      "summary": "One named environment of an application: its running version, services, logs, and data.",
      "owners": [
        "PLD-L0-40",
        "PLD-L0-96"
      ]
    },
    {
      "name": "version",
      "summary": "One built, deployable version in an application's history.",
      "owners": [
        "PLD-L0-63"
      ]
    },
    {
      "name": "secret",
      "summary": "One named secret under custody; the name is the reference, the value never returns.",
      "owners": [
        "SCRT-L0-01"
      ]
    },
    {
      "name": "token",
      "summary": "A minted token: the unattended credential, bounded at its minting to the whole account or to one application and holding the grants its minting session held, its value returned once and its identity carried on every record.",
      "owners": [
        "API-L0-05",
        "MAPI-06"
      ]
    },
    {
      "name": "pending_action",
      "summary": "One requested destructive action awaiting the browser's approval.",
      "owners": [
        "API-L0-07"
      ]
    },
    {
      "name": "library",
      "summary": "The published system library the platform serves, registry-style: the catalog of published entries and their immutable versions.",
      "owners": [
        "API-L0-14"
      ]
    },
    {
      "name": "public_files",
      "summary": "The public files origin's three containers: `plugins` holds tzTeam's approved plugin release set at `/plugins/` and `packages` the committed packages folder at `/packages/`, each served ungated with a request path per blob and published whole from its committed folder; `site` holds the website's published versions, read by the control plane's management and accounts services and by no browser.",
      "owners": [
        "PLD-L0-68",
        "PLD-L0-71",
        "PLD-L0-75"
      ]
    },
    {
      "name": "area",
      "summary": "One declared storage area: the named file container an application reaches through the object storage surface, its two minting declarations recorded at declaration.",
      "owners": [
        "OST-L0-01"
      ]
    },
    {
      "name": "upstream",
      "summary": "One declared upstream: the external API an application reaches through the Egress Gateway, the credential applied from custody at the platform's edge.",
      "owners": [
        "EGW-L0-01"
      ]
    },
    {
      "name": "realm",
      "summary": "One application's end-user realm on the accounts service: its declared sign-in methods, creation mode, and limits, and the end users it holds.",
      "owners": [
        "ACS-L0-07",
        "ACS-L0-08"
      ]
    },
    {
      "name": "push",
      "summary": "One application environment's push service: its providers, by their identifiers and stored credential names, the devices its users registered, and its deliveries.",
      "owners": [
        "PSH-L0-01",
        "PSH-L0-02",
        "PSH-L0-04"
      ]
    },
    {
      "name": "platform_context",
      "summary": "Shared platform contracts, guides, skills and documentation.",
      "owners": [
        "CTX-07"
      ]
    },
    {
      "name": "connection",
      "summary": "A signed-in tool's connection: one OAuth 2.1 refresh family of the account, opened at a sign-in and renewed without the person, listed, given its products, and ended one at a time on the account grain beside sign_out_everywhere, which ends every session at once.",
      "owners": [
        "API-L0-21",
        "MAPI-19"
      ]
    }
  ],
  "actions": [
    {
      "name": "start",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "admits": [
        "device_sign_in"
      ],
      "summary": "A connection's first read: the acting account (`id` and `standing`), the connection's credential (`credential`, a minted token's grants among it, with whether it admits test end users on production), the products the account holds under the profile rule (`products`), and its tzCloud applications as `list_applications` returns them (`applications`, absent where the account does not hold tzCloud), with `product_lines`, a line for each other product whose tools the connection lists and whose state `start` reads, empty where it lists none.",
      "owners": [
        "MCP-08"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_account",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "admits": [
        "device_sign_in"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The connected identity and its standing. For the session credential and the browser session it also returns the provider-verified address (`address`, null where none is held), the acting credential's grants (`grants`), and the sign-in instant the credential carries (`signed_in_at`: the API cookie's own for a browser session, null for a bearer at this revision), so a page can render a sign-in link in place of each control once the freshness window has passed, and the account's passkey standing (`passkeys`: the counts `held` and `stranded` and nothing of a credential, null where no passkey ceremony is served); an authorized computer's token receives `address` alone, and the platform credential and every other minted token receive none of the four.\n\nA session credential, a browser session or an authorized computer's token also gets `image_generation`: the month's `used` and `resets_at`, with `cap` under `plans` or `free_images` under `usage`. Other minted tokens and the platform credential receive no such member. If its usage row cannot be read, the member is omitted.",
      "owners": [
        "MAPI-03",
        "WEB-L0-16",
        "ACB-L0-92",
        "ACB-L0-76"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_balance",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The connected account's balance, threshold and warning record, pause state, and usage lines for the current UTC month. Lines give monthly totals and their open-day parts by application, rate key and environment. Live applications give recorded size, environment sleep settings, log refusals within the last day, and the database connection limit per process. The answer includes the estate's pricing model. The read writes nothing.",
      "owners": [
        "API-L0-27",
        "ACB-L0-98"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_purchases",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Read your account's credit purchases, newest first, including each purchase's state and its grant's expiry where recorded. Pass `purchase` for one id. An id belonging to another account gives an empty list. The answer includes whether sales are open, the purchase amounts and currency. This read changes nothing.",
      "owners": [
        "API-L0-27",
        "ACB-L0-44",
        "ACB-L0-101",
        "ACB-L0-102"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "buy_credits",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Request a link for the account owner to buy account credit. If credit sales are off on this site, the call refuses and opens no checkout. The provider is the seller. The owner opens the link and pays on the provider's page. This tool pays nothing and the answer grants no credit.",
      "owners": [
        "ACB-L0-101",
        "ACB-L0-102"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": true
      }
    },
    {
      "name": "read_rate_card",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "summary": "Read the current rate card with no arguments. It returns one item per registry key: its unit, price, effective UTC day and `unset`, whether no rate is in effect. A missing rate is null, never zero. This read serves once pricing reads usage; before then it refuses `invalid_request`. It returns no reason, stamp or author.",
      "owners": [
        "PRC-L0-16",
        "PRC-L0-02"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "export_account",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "summary": "The export escape: the account's declarations as one JSON document — the account record, the applications with their manifests, the realm configurations with their device counts, the push configurations, the storage area declarations, the secret names (never values), the upstream declarations, and the token records — with the feedback and the account's own tzTrack spaces, and no tzMesh data, stamped with the time of the read. A product it cannot read leaves the export marked `partial`, with that product in `products_not_read`. The databases' contents and the areas' files leave per application and environment through `request_export`.",
      "owners": [
        "ACB-L0-47",
        "API-L0-18"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "link_identity",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "summary": "Link a second federated identity to the signed-in account through the guided linking flow; linking is never by email equivalence.",
      "owners": [
        "ACB-L0-03"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": true
      }
    },
    {
      "name": "delete_account",
      "resource": "account",
      "tier": "destructive",
      "surface": "account",
      "addresses": [
        "tzop"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The erasure route, through the pending action.",
      "owners": [
        "MAPI-05",
        "API-L0-12"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "sign_out_everywhere",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "End every session of the account at once: every browser's cookies and every connection made through a sign-in, your own included, each signing in again. Your passkeys and the tokens you minted keep working. The header's Sign out ends one browser alone.",
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      },
      "owners": [
        "ACS-L0-18",
        "ACS-L0-11",
        "MCP-10",
        "WEB-L0-21"
      ]
    },
    {
      "name": "list_applications",
      "resource": "application",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The account's applications with deployment history, declared feature flags and environments. Each environment gives its state (deploying, deployed, `failed`, never_deployed, halted or deleting, as read_status returns), serving version, hostname, compute grain and halted_at, null while not halted. Deployment history includes successful deploys, promotes and rollbacks, and excludes restarts and failures.",
      "owners": [
        "PLD-L0-127",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "create_application",
      "resource": "application",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Create an application for the account.",
      "owners": [
        "ACB-L0-22",
        "PRC-L0-04",
        "ACB-L0-83"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": false
      }
    },
    {
      "name": "submit_manifest",
      "resource": "application",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Declare or change the manifest, a deliberate act, refused with the failing path. It records the upstreams member's declarations as declare_outbound_api records them. A deploy runs under the recorded manifest alone, so submit again after each edit to the project's manifest.json, except an edit to its `application` member alone. The submission `turnzero provision` prints, passing `local_run` beside `code_challenge`, also returns four command forms under `provisioning`. `provisioning.command_npx` writes a local run's settings under a short-lived grant; `provisioning.command_npx_windows` is its Windows form. `provisioning.command` and `provisioning.command_windows` use the installed turnzero command. That answer withholds the credential values a first submission otherwise returns once, and over the HTTP API its `provisioning.next` says where they are. `next` lists each `store_secret` call a name not stored yet waits on.\n\nThe answer's `health.gated` says whether the router's sign-in check covers the health path for a request with no session. The deploy's `health_gate` step calls the path from inside the platform whatever `gated` says.",
      "owners": [
        "ADM-L0-07",
        "MAN-12",
        "EGW-L0-02",
        "PLD-L0-63",
        "ADM-L0-05"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "check_manifest",
      "resource": "application",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Check a whole manifest for your application without recording it or setting anything up. Runs `submit_manifest`'s checks before any change and returns `checked`, `changed`, and `difference`, listing paths added, removed or changed. A refusal gives the same failing path, status and error as submission. This does not predict sign-outs, or refusals from setup steps or custom-domain writes. Call `submit_manifest` with the manifest to apply it.",
      "owners": [
        "API-L0-24",
        "MAPI-34",
        "MAN-12"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true
      }
    },
    {
      "name": "read_status",
      "resource": "application",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Read one application's record, labelled `environment: \"production\"`: the production environment's state and `compute_state`, with the recorded version, hostname, `size`, `production_sleep`, minimum replica count (`warm_floor`), and `egress_mode` (`observe` or `enforce`). An optional `environment` chooses the environment those members describe instead, its own hostname included before any deployment too. Its `environments` member holds one member per environment the application has, production alone on a new application. Each carries its state, the first that holds of `deleting`, `halted`, `deploying`, `deployed`, `failed`, and `never_deployed`, the words `list_applications` returns. Each carries its `compute_state`, the provider's own word for its compute, null until compute exists, and its compute grain (`container` or `pod`) with its `grain_reason` and `grain_note`. Each carries its serving version, its hostname, its cell, its provisioned database row, and its in-flight or last deploy. That deploy's `worker_heartbeat_at` is the deploy worker's liveness, never the application's. Its `outcome` on a failed row carries the refusal and, for a failed health gate, the `gate` member, which `list_versions` carries too. That member holds the probe ledger, what replied, the candidate's state, and its last console lines. Each `environments` member carries its own environment's provisioned database row in its non-secret fields (`database`: the database name, the role name, the server host, the provisioning instant, and the environment). `database` is null where that environment has no database, and the development database is returned as soon as a submission provisions it. Where the request carries `tables: true`, the member also carries that database's table names, read under the platform's own connection (`tables`). A failed read gives `tables: null` with `tables_error` describing the failure. The top-level `database` and `tables` members describe the environment the call passes, production where it passes none, as the other top-level members do. On an application with one environment, the top-level `local_run_database` gives development's database row, which local runs use, without its credential. The `pending_upload` of the environment a deploy goes to lists an upload whose file landed within a day and that no deploy has read, its start refused or never made. It carries the `deploy` call that starts it, or, where the zip itself was refused, no call: the way on is a `deploy_command` call and the command it returns. While the command's upload has not landed and its grant has not expired, `upload_in_progress` lists it with that expiry, and a read held by `wait_seconds` holds on it, `settled` false. While a deploy row is in flight, the environment's deploy member gives its `step` and the step's start (`step_started_at`). During the health gate it also gives `gate_progress`: the probes made, the gate's bound, and the last probe's status or transport word. With `brief: true`, the answer keeps the summary, the members that say whether each environment is up, and each last deploy's `outcome` whole. It leaves out the rest, `timings`, the grain members, and the database rows among them. With `wait_seconds` (1 to 45), the answer is held until no deploy, promote, or restart of the application is in flight, and it carries `settled` and `waited_ms`. The answer leads with a one-line `summary`. A second held wait for the same application, including an act's own wait, returns at once, its `settled` from its own read. Without a wait, read every ten seconds.\n\nThe `application` member's `egress` member lists the outbound destinations the serving version reached that the manifest does not declare. It holds at most twenty hosts with their counts, their last instants, and the manifest edit that declares each, the total beside them, since the version's start or the last seven days, whichever is later. A host that a declared upstream of the application uses also carries `upstreams`, and its remedy gives that upstream's gateway route before the manifest edit. Its `read` member is `logs`, `unavailable` where the store did not reply, in time or at all, or `skipped` while a deploy is in flight. Under the super_admin grant it reads an application of any account, `withheld` then standing here and in `server_errors`; that read leaves out the settings lists, and each `outcome` keeps its refusal, step, and gate statuses without console lines, bodies, or details. Where the serving version reached an undeclared destination, the summary states their count and identifies the member, and the member's `earlier` gives `read_logs` for what came before the window.",
      "owners": [
        "PLD-L0-127",
        "PLD-L0-136",
        "PLD-L0-63",
        "PLD-L0-59",
        "DBS-L0-01",
        "WEB-L0-17",
        "ACB-L0-22",
        "EGW-L0-17",
        "PLD-L0-40",
        "MAPI-04",
        "PLD-L0-89",
        "PLD-L0-86",
        "PLD-L0-105",
        "PLD-L0-84"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true,
        "idempotentHint": true
      }
    },
    {
      "name": "set_app_size",
      "resource": "application",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Set your application's size, whether production sleeps when idle, or both. Make either change only at the account owner's request. Ask for any size or sleep choice they have not made. If nobody can answer, change nothing and report. A deployed production size change normally re-creates compute, with one cold start outside the request path. With `applying`, nothing is recorded yet: read `read_status` with `wait_seconds` for its end and the size then in effect.\n\n`shared-0.5gb` is smaller and `shared-1gb` larger; choose the larger for more memory or CPU. Neither size scales beyond one replica or includes usage capacity. Smaller production uses shared compute; larger production has its own container. Read `read_status`'s `production_sleep` for the setting in effect, whether recorded or defaulted; size alone does not determine the default. Sleeping accepts a cold first request. Development keeps its default size and always sleeps.\n\nPass at least one of `size` and `production_sleep`; null is treated as omitted. `changed` lists recorded values. With `applying`, `changed` is empty and `application` still holds the old values. The redeploy records requested values only when new compute takes traffic; failure or cancellation records neither. An unchanged value writes nothing.\n\nRead `read_status` with `wait_seconds`, following `applying.environment` and `applying.version`, for completion and the size then held. Failed re-creation reads `failed` while production serves its earlier compute; the same call retries it. Do not repeat the act merely to confirm.\n\nEvery call before pricing reads usage refuses `invalid_request`. That also covers no held size, neither change supplied, an unknown size or non-boolean sleep setting. `no_such_application` means the id is absent from your account. `deploy_in_flight` means production has a version in flight; wait for its end. A sleep-only change may carry the compute's own refusal; a failed write is `entitlement_apply_failed`, retried with the same call.\n\nOn a size move, `plan_schedule_conflict` means standing schedules do not fit the target. Unset quantities and unresolved placement carry their own refusals. `target_environment_halted` means production is halted; `deploy_seam_absent` means no live provider seam is bound. `entitlement_apply_failed` covers a failed compute or connection-limit write, and re-creation may refuse to start by name. Passed-through refusals keep the underlying act's name and detail.",
      "owners": [
        "API-L0-28",
        "ACB-L0-22",
        "PRC-L0-04",
        "PRC-L0-05",
        "PLD-L0-63",
        "PLD-L0-84"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "set_log_retention",
      "resource": "application",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Turn your application's longer log retention on or off. Turn this option on or off only at the account owner's request. If their choice is missing and nobody can answer, leave it unchanged and report. Turning it on charges for the days left in the calendar month, including today. A repeat charges nothing. Turning it off gives nothing back. The next retention run deletes entries older than seven days. Turning it on again cannot restore them. The answer's `log_retention_days` is the recorded state. Nothing continues in the background for this act.\n\nPass `days` as 30 to turn the option on or 7 to turn it off. Turning it on sets the option only after the month's charge is posted or already covered. An unbilled account bypasses the balance check and incurs no real charge. The option has its own retained-bytes bound; log writes past it refuse `log_capacity_reached`.\n\nEvery call before pricing reads usage refuses `invalid_request`, as do other days values and an application that holds no size. `no_such_application` means the id is absent from your account. A turn-on refuses `balance_short` where balance left is not more than the month's charge for the days left. `rates_unread` means rate rows or the switch instant could not be read when a new charge was needed; nothing was charged, so try shortly. `option_not_set` means the option was not turned on, and any posted charge remains. If the application still exists, retry: in the same UTC calendar month, no further charge is posted while the month's charged count covers your log options, including this one. Turning off charges nothing. No further state read is needed beyond the returned `log_retention_days`.",
      "owners": [
        "API-L0-29",
        "ACB-L0-26",
        "LGS-L0-14",
        "PRC-L0-16"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_usage",
      "resource": "application",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Read the application's UTC-month usage for backend actions, data transfer, stored data, the AI allowance, push messages and email recipients. Each measure gives `month_total`, source timestamps in `includes_before`, `state`, `resets_at` where a refusal ends, and `refuses`. Its `quota` is the size's quantity where it has one: stored data and push messages. It is null for backend actions, data transfer, the AI allowance and email by the month. The states are `ok`, `warning`, `over`, `unset` and `unknown`. After a successful deploy, the plane attempts the first check if the application has no recorded check. Backend actions count one per request the serving router forwards to the application's backend, a scheduled run among them, one per data message a client sends on a WebSocket, plus each end-user sign-in and each session verification the accounts service performs. A request the router verifies itself counts once. The router's count reaches `month_total` in a minute (a WebSocket message's in two), sign-ins and verifications at the daily check. For traffic, the total includes this month's router counts and the check's terms when the check ran this month. Stored data gives the last check's reading, or null before that check. The AI allowance, push messages and email recipients give their reading at the call. Add nothing to `month_total`. A backend actions, data transfer, or stored data measure with no recorded state reads `unknown` where `month_total` is null, else `unset` where `quota` is null, `ok` below 80% of `quota`, and `unknown` otherwise. The two traffic states are recomputed on each router report the control plane folds, and the stored-data state at each check. An over state refuses by name. Where a traffic quantity applies, an over traffic state makes the serving router refuse application requests with 429 `usage_over_quota` until the next UTC month's first instant. No size has a traffic quantity. The object storage surface refuses file puts on bound areas until the next successful daily pass or a raised quantity. Meanwhile reads and changes of size continue, but over stored data also refuses a new deploy's upload, `deploy_files` with file contents or a stored entry, and `generate_image` with `application` set to that application. With no application given, it reads every live application of the account. The AI allowance, push messages and email recipients are counted at each call or send, each state computed at the read and joining no overall state. An `over` month state refuses the corresponding calls or sends until the next UTC month's first instant. Where their count was read, email recipients also give hour and day counts with their own quotas and reset instants. `refuses` is `requests`, `file_puts`, `ai_calls`, `push_sends`, or `email_sends`.\n\nEach application's `egress_limits` member reads its outbound limits: `connections_per_minute` (per tunnel proxy replica), `bytes_per_day`, `bytes_today`, `refused_today`, `state` (`ok`, `capped`, or `unset`), and `resets_at`, the next UTC day's first instant. An Unset limit is no bound, and `state` reads `unset`.",
      "owners": [
        "ACB-L0-26",
        "CHI-L0-09"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "delete_application",
      "resource": "application",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Delete the application and everything provisioned for it.",
      "owners": [
        "MAPI-05"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "purge_logs",
      "resource": "application",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Erase the application's log entries and counter totals ahead of retention: one environment's, or every environment's where none is given. It is your own purge under the approval flow, never undone, the control plane's record untouched.",
      "owners": [
        "LGS-L0-19",
        "LGS-L0-18",
        "MAPI-05"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "deploy",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Deploy a built artifact to the environment the application's deploys go to: production on an application with one environment, and development on one with two, where production receives a version through `promote`. The command alone passes `zip_sha256`, on the HTTP action route, and over this connection a call that passes it is refused `local_route_required`. Called with that `upload`, by the command's start or by a retry of a start refused or never made, it starts the deploy. So does a call with an `artifact` in a storage area bound to the application. It returns 202 `deploying`, or, with `wait_seconds` up to 45, holds its answer until the deploy ends. The compute grain is chosen before any compute act: a development environment of either size, and the production environment of a `shared-0.5gb` application, run as a pod in the hosting cell's admitting group of its kind with headroom, and as a container app where the cell has none. The production environment of a `shared-1gb` or unlimited application runs as its own container app. A full group is refused `group_full` and a row in a group of another kind `group_kind_mismatch`. A grain that differs from the existing compute's is the grain migration, the previous compute deleted after its hold. The hosts a manifest's `egress` member declares are reached in the tunnel mode with no key applied; a host called on a stored key is a declared upstream (`declare_outbound_api`), its key applied at the gateway's edge, and the container holding at most the upstream's egress key. The start may pass `commit`, the commit the code was built from. The version keeps it, its promote and rollback carry it, and so does the build row the platform writes into the application's own issue-tracking space. On a deploy to production, `rotate_database_credential` true also sets a new production database password, as a promote does; the command's preparing call records it for the upload's start. Its answer leads with a `summary`; unsettled, it gives the `next` call, a `read_status` that shows the `step`.\n\nAn answer that is not this platform's own, such as a gateway's error page or a closed connection, says nothing about whether the deploy started. Read `read_status` with `wait_seconds` first: the deploy started only where the environment's deploy member shows the kind deploy with a `started_at` later than your call. Where `pending_upload` still lists the upload, its start was not made: make the call its `retry` carries. Call again only where that read shows no start.\n\nChoose the route with read_documentation, page /cloud/getting-started/ways-to-deploy/.",
      "owners": [
        "PLD-L0-63",
        "MAPI-04",
        "PLD-L0-127",
        "PLD-L0-136",
        "PLD-L0-43",
        "MAN-09",
        "EGW-L0-11",
        "EGW-L0-01",
        "PLD-L0-40",
        "PLD-L0-41",
        "PRC-L0-16",
        "OST-L0-01",
        "OST-L0-08",
        "PLD-L0-86",
        "PLD-L0-90",
        "SEC-L0-18",
        "ITS-L0-02"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "check_deploy",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Check a deploy before making it: pass the application, and the call returns each refusal a deploy's start would make now, writing nothing. Call it before `deploy_command`, on a first deploy and after fixing what it reports. `refusals` lists each refusal the application's state would draw, in the deploy's order: a deploy in flight, the database, a missing secret, the daily deploy cap, a halted production, or the hosting cell's room. An empty list means the application's state would refuse none; it does not clear your code. `command_npx` checks your code; `command_npx_windows` is its Windows form. `command` and `command_windows` use the installed turnzero command. This call leaves `zip_checked` false.",
      "owners": [
        "API-L0-24",
        "MAPI-25",
        "PLD-L0-107",
        "PLD-L0-94"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true,
        "idempotentHint": true
      }
    },
    {
      "name": "deploy_command",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Return the command that zips, uploads, and deploys the application's folder when run; this call writes and starts nothing. It takes the application and optionally environment, local_path, wait_seconds, and rotate_database_credential. It returns 200 at once with state `awaiting_command`, the line as command, command_windows, command_npx, and command_npx_windows, and next, the read_status call to make if the command returns before the outcome. The lines carry no credential: the command reads its own on the computer that runs it. A hosted connector's session receives no line; detail gives the deploy_files call instead. fallback gives deploy_files. Choose the route with read_documentation, page /cloud/getting-started/ways-to-deploy/.",
      "owners": [
        "PLD-L0-86",
        "PLD-L0-94",
        "PLD-L0-96",
        "PLD-L0-104",
        "API-L0-25"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true,
        "idempotentHint": true
      }
    },
    {
      "name": "deploy_files",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Deploy a small application through the signed-in connection with inline content or files stored in its storage areas. It takes no folder path or ZIP. Choose the route with read_documentation, page /cloud/getting-started/ways-to-deploy/.\n\nPass the application and environment as `deploy` takes them. Send `files` in one call, each with `path` and either `content` or `stored`, including root `package.json` for a server (a serverless application needs none); the platform hashes the bytes it receives, so no hash command runs in your shell. Where the files together are too large for one call, send some first as `file`, and list them in `files` by the `sha256` the answer's `kept` gives. The answer lists under `missing` each file the platform does not have, and under `warnings` the files whose names look like keys or credentials. It lists under `left_out` the files a deploy never includes: `node_modules`, `.git`, `.env`, every `.env.*`, and the AI coding tools' own files, such as `.claude` and `.mcp.json`. The list call that leaves nothing missing starts the deploy and replies as `deploy` does. `check_only` true only checks them. \n\nFor a binary file you cannot read, declare a storage area with `declare_storage_area` if the application has none. Get the page's address from `read_status`'s `dashboard`, passing `brief: false`. Ask your user to sign in there and use Upload a file, then use `{ path, stored: { area, name } }`. Send no file holding a secret value; store secrets on the site's secrets page.\n\nThe platform never reads your folder, so a file the list leaves out is not in the new version, even where an earlier version held it. A library entry's copy you took is the one exception: where your `package.json` declares it and the list leaves it out, the platform fills it from the library.\n\nInline files are limited to 512 KiB each. Stored entries have no per-file cap. Both count toward 200 entries and 4 MiB total; filled library files also count toward the total. A JSON, JavaScript, or TypeScript file that does not parse is refused. Send binary bytes as base64 with `encoding` `base64`, or use `stored: { area, name }`. The JSON body has a separate 4 MiB limit, refused `request_too_large`. Base64 adds about a third, so split large inline requests into `file` calls.\n\nBeyond the total or entry caps, use the command if it works and you have a shell and the app's whole folder or the upload route if the command cannot work and you have a shell. Declare a storage area if needed, call `mint_upload_grant`, upload the ZIP, then call `deploy` with it as `artifact`. The ZIP route needs a shell; with no shell, ask the person to deploy from a computer with one.\n\nAn answer that is not this platform's own says nothing about whether the deploy started: read `read_status` with `wait_seconds` first, and call again only where it shows no start.",
      "owners": [
        "API-L0-25",
        "MAPI-04",
        "MAPI-26",
        "OST-L0-01",
        "OST-L0-03",
        "OST-L0-05",
        "PLD-L0-63",
        "PLD-L0-86",
        "PLD-L0-94",
        "PLD-L0-96"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "promote",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Promote a version the history holds to production with production's own settings and credentials: the development environment's serving version, or the version you pass. It reuses the image built at deploy, so a version whose image the platform's retention deleted is refused `version_image_pruned`. It replies at once with the state `deploying` and `next`, and completes detached, read to its end through `read_status` and `list_versions`. With `wait_seconds` up to 45 it holds its answer until the promote ends, leading with a `summary`; an answer that did not settle gives the `next` call. On an application with one environment, whose deploy reaches production itself, it is refused `environment_not_created`, and the refusal gives `create_environment` and `roll_back`.\n\nAn answer that is not this platform's own, such as a gateway's error page or a closed connection, says nothing about whether the promote was made. Read `read_status` with `wait_seconds` first: the promote started where `environments.production.deploy` shows the kind promote with a `started_at` later than your call. Call `promote` again only where that read shows it did not start.",
      "owners": [
        "PLD-L0-43",
        "PLD-L0-63",
        "MAPI-04",
        "DBS-L0-02",
        "SEC-L0-07"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "read_logs",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The environment's log entries written through the logging service, filterable by time, level, message, field, and source. `source` selects one of the stream's sources. `app` is only what the application writes through the logging package; standard output and standard error land under `container`. `platform` is the platform's entries about it, each scheduled run's outcome among them. `router` is the serving router's `legs_ended` records per invocation kind and outcome per minute, its `window_ended` requests whole, and its `upstream_ended` requests whole, each a request an application's process end cut. It also holds its `source_refused` records, one per minute the per-source bound refused requests in. Its `sockets_ended` records are one per minute and reason WebSocket connections ended, with the close code, the count, and the durations. `egress` is the tunnel seat's `egress_establishments` records per host and outcome per minute, an observed host's refusal name and remedy on them, and its refusals whole. `harness` is the runtime harness's connection observer's `egress_establishments` records and its failed `egress_establishment` records, shipped from the application's own process. `all` is every source the logging service stores, with the container's console output merged by time unless you pass `level`, `field`, `filter`, `contains`, or `until`. `container` is the one console read, the named environment's own compute (production where none is given; a pod's live console read through the cluster's API server, after the first and last lines of the environment's ended pods, marked `[pod-ended]`). It is where the process's standard output and standard error land, `console.log` and `console.error` lines among them, beside the `process_ended` and `harness_refusal` lines and the logging client's fallback lines. `filter` is the declared-versus-observed reading: `declared` or `undeclared` against the manifest's egress member, over the aggregated records with the platform endpoints and the loopback targets subtracted. The `legs_ended` record of a leg that got a response carries its `status_class`, and each 5xx response is kept whole as an `answered_5xx` record, under a per-minute cap. A 504 refusing a request whose process had not started listening in time is kept as a `start_timed_out` record instead, under the same cap. Store entries land within a few seconds, and on the container grain a `container` line reaches the log workspace up to about a minute after it is written. On the container grain, where the platform has the direct read enabled, the read also reads each running replica's console directly, once. Where that direct read succeeds, it returns the newest lines at once. A `container` answer is ordered by each line's write time, on the pod grain pod by pod with the ended pods' lines first, and a line from the environment's recorded previous compute carries `[retiring]`. An empty answer, or one whose window ends inside that lag, carries a `detail` saying why. On the container grain, where the direct read is enabled, that `detail` also reports it. It gives the time from which lines were read from the replica directly where any were kept. It says when lines may still be in the ingestion, and gives a failed read's reason. On a `container` read, `contains` searches its newest 1,000 lines, and a `level` or `field` is refused `invalid_request`, a console line carrying neither.",
      "owners": [
        "SVC-L0-15",
        "SVC-L0-07",
        "SVC-L0-18",
        "HST-L0-03",
        "HST-L0-01",
        "PLD-L0-136",
        "PLD-L0-137",
        "EGW-L0-17",
        "EGW-L0-15",
        "PLD-L0-40",
        "MAN-09"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true,
        "idempotentHint": true
      }
    },
    {
      "name": "request_route",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Make one HTTP `GET` request to a route of your own deployed application and read what it returns: the status, the headers, and the body. Call it after a deploy, from a tool with no shell, for each changed route that reads. To send `POST`, `PUT`, `PATCH`, or `DELETE`, call `write_route`. Pass the application’s `id` and the path, opening with one `/`. `environment` is `production` where you give none, so give `development` to request the development copy. The platform builds the address from the environment's own hostname and takes no host from you. A redirect is followed only on the same hostname over https, at most five; any other redirect comes back as the result. The body comes back up to 64 KiB, or the lower `max_body_bytes` you pass, `truncated` true past it, and the call ends within 20 seconds. One account makes at most 60 requests a minute, shared with `write_route`. Each `routes` entry counts as one request. `routes` takes up to five requests in one call, one `test_end_user` sign-in serving them all. Each request may carry `expect`, the status it should return; a match counts as passed, including a deliberate 401 or 404.",
      "owners": [
        "API-L0-26",
        "MAPI-28",
        "SVC-L0-07",
        "EGW-L0-01",
        "PLD-L0-67",
        "PLD-L0-59"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true,
        "idempotentHint": true
      }
    },
    {
      "name": "write_route",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Send one HTTP `POST`, `PUT`, `PATCH`, or `DELETE` request to a route of your own deployed application and read what it returns: the status, the headers, and the body. The request reaches your running code and can change its data, production's included. To send `GET`, call `request_route`. Pass the application, the method, and the path, opening with one `/`, and a body where the route reads one. Name `environment` as `production` or `development`, the copy whose data the write reaches; without it, the call is refused `invalid_request` before any request. The platform builds the address from the environment's own hostname and takes no host from you. A redirect is followed only on the same hostname over https, at most five; any other redirect comes back as the result. The body comes back up to 64 KiB, or the lower `max_body_bytes` you pass, `truncated` true past it, and the call ends within 20 seconds. One account makes at most 60 calls a minute, `request_route`'s counted with them. `routes` takes up to five requests in one call, each with its own method, one `test_end_user` sign-in serving them all.",
      "owners": [
        "API-L0-26",
        "MAPI-28",
        "SVC-L0-07",
        "EGW-L0-01",
        "PLD-L0-67",
        "PLD-L0-59"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "read_counters",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "The environment's counter totals by name over a window, at the hour or day grain (the logging service).",
      "owners": [
        "PLD-L0-40",
        "LGS-L0-15"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "roll_back",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "product": "cloud",
      "summary": "Put an earlier version back into production with that version's code, setting bindings and plain values. The serving version is refused `version_already_serving`, and a newer one `version_newer_than_serving`. It replies and waits as a promote does, `wait_seconds` up to 45 holding its answer until it ends. It works on an application with one environment too, where you pass one of production's own earlier versions.\n\nAn answer that is not this platform's own, such as a gateway's error page or a closed connection, says nothing about whether the rollback was made. Read `read_status` with `wait_seconds` first: the rollback started where `environments.production.deploy` shows the kind promote, which a rollback's row has, with a `started_at` later than your call. Call `roll_back` again only where that read shows it did not start.",
      "owners": [
        "PLD-L0-43",
        "PLD-L0-57",
        "MAPI-04"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "halt_environment",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "product": "cloud",
      "summary": "Halt your deployed environment without deleting it: requests to its hostname are refused 503 `environment_halted`, its schedule rows leave the tick's claim, and its version, data, credentials, and declarations remain. Production's compute stops. A halted development environment serves nothing, and its compute stops when idle at the latest, for either size. A container app stops in the call, and a pod's scaler is paused at zero within about 11 seconds after it. A halt on a halted environment returns `unchanged`. A halt of production is an account action: admitted under the account's session or a minted token scoped to the whole account, and refused 403 `account_credential_required` under a minted token bounded to one application, so that a leaked application-bounded token cannot stop production; a development halt and `halt_environment` with `resume: true` keep the bounded token's admission. A halt is refused `deploy_in_flight` while a deploy, promote, or restart of the environment runs, save one case. A halt of production while a production deploy is still building its image is admitted and ends that deploy; past its build, the halt is refused until the deploy ends. With `resume: true`, the hostname responds again and every schedule row restarts from the resume instant. Production's compute starts; development of either size starts on its next request. A resume on a running environment returns `unchanged`; a deploy to a halted development environment also ends its halt.",
      "owners": [
        "PLD-L0-41",
        "PLD-L0-47",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "create_environment",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "This call turns on an application's development environment. Turning development on removes no production test end user. Your signed-in session or a token with the `test_end_users` grant can still create them on production. New applications have only production and deploy there. With development on, `deploy` targets it. `promote` moves a version to production. The optional `environment` accepts only `development`. The call finishes before returning. It creates development's sign-in realm if the manifest declares accounts, records realm and push settings, and declares schedules. It provisions no database. `submit_manifest` provisions development's database before or after this call. Nothing runs there before its first `deploy`.\n\nIf development is already on, the answer is `created: false`. The call still repairs realm, settings or schedule steps a failed call left incomplete. `delete_environment` turns development off.",
      "owners": [
        "PLD-L0-96",
        "PLD-L0-40",
        "ACS-L0-21"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "idempotentHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "restart_application",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "product": "cloud",
      "summary": "Restart one environment's running copy, re-applying the bindings its serving version recorded, each reading its secret's current value; a binding the manifest added since takes effect at the next deploy or promote. The platform re-creates its serving compute from the version it already serves, under the settings the platform holds now, the application's current hostname among them, with no build and no new version. It replies at once with the state `deploying` and `next`, and completes detached, read to its end through `read_status` and `list_versions`. With `wait_seconds` up to 45 it holds its answer until the restart ends. A restart spends none of the application's deploys per day, and it is refused `deploy_in_flight` while any deploy, promote, or restart of the environment is in flight.\n\nAn answer that is not this platform's own, such as a gateway's error page or a closed connection, says nothing about whether the restart was made. Read `read_status` with `wait_seconds` first: the restart started where the environment's deploy member under `environments` shows the kind `restart` with a `started_at` later than your call. Call `restart_application` again only where that read shows it did not start. Under the super_admin grant the call also takes `placement`, `standing` or `rule`, over any account's application. `rule` runs the placement rule once for the application's size and sleep setting. This operator act moves an existing `shared-0.5gb` production environment onto the shared grain.",
      "owners": [
        "PLD-L0-84",
        "PLD-L0-63",
        "MAPI-04",
        "PLD-L0-136"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "apply_migration",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [],
      "product": "cloud",
      "summary": "The migration action: drain, snapshot, apply, atomic resume.",
      "owners": [
        "PLD-L0-56"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "restore_snapshot",
      "resource": "environment",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [],
      "product": "cloud",
      "summary": "Restore a snapshot, discarding state written since.",
      "owners": [
        "PLD-L0-57"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "delete_environment",
      "resource": "environment",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Delete the development environment and what it holds — container, database, realm, credentials, files, logs, and its version rows withdrawn from `list_versions` — keeping the application and its production environment; production is deleted only with its application. Afterwards a deploy goes to production. On one environment the call is admitted where development's records remain: a database setup, whole or stopped partway, a deletion of them that stopped, or a record an earlier version of the platform left. It then erases them, the secrets, files, and logs kept for local runs among them, and the next submit_manifest sets the database up again. Otherwise it is refused `environment_not_created`.",
      "owners": [
        "PLD-L0-66",
        "PLD-L0-40",
        "MAPI-05"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "clear_development_database",
      "resource": "environment",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Clear the development database: drop it with every table and row in it, and create it again empty under the same role. The development credential and the environment file's connection string stay valid. `restart_application` on development, or a deploy, then runs the application's migrations, which rebuild the tables. Production's database is never cleared.",
      "owners": [
        "DBS-L0-10",
        "PLD-L0-40",
        "MAPI-05"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "query_database",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Run one read-only SQL statement against an environment's database and read a bounded page of its rows. The statement's first word is SELECT, WITH, VALUES, or TABLE, and it runs as a cursor's query on a session of its own, under the environment's own database role, in a read-only transaction that is always rolled back, with a 10-second statement timeout. The answer carries each column's name, at most `limit` rows (100 where none is given, 1,000 at most) and 64 KiB of row data, each value in PostgreSQL's text form or null, `truncated` (`false`, `rows`, or `bytes`), and the time taken. A write is refused `query_not_read_only`; any other failure of the statement or its session is refused `query_failed`. Only the application's own account reaches the action. `environment` is production where none is given; `development` reads the development database, a one-environment application's local-run database included. Neither the statement nor any value it reads is written to the platform's log.",
      "owners": [
        "DBS-L0-11",
        "PLD-L0-40",
        "MAPI-04"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "list_versions",
      "resource": "version",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "An application's version history, newest first: each row's environment, number, kind (deploy, promote, or restart, the last the re-creation of a serving revision under current settings by `restart_application`, a rename, or the platform), state, artifact hash, instants, and outcome. The outcome carries `result`, and the `gate` evidence of a failed health gate or a failed build's last lines. Each row says whether it is serving and whether it is promotable, false once the platform's retention has deleted its image. It carries its step `timings`, and its harness hash with whether that harness is the platform's current one, which a promote keeps and a new deploy takes; the rows are those promotion and rollback name.\n\nEach environment's serving row alone also gives `kept`: its recorded file paths and SHA-256 hashes sorted by path, or null where none were recorded. Each listed hash can replace `content` for that file in `deploy_files` while the version serves.",
      "owners": [
        "PLD-L0-84",
        "PLD-L0-59",
        "PLD-L0-63",
        "PLD-L0-89",
        "PLD-L0-90"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "store_secret",
      "resource": "secret",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Put a value into custody under a declared name. The value travels as a `POST` to this action's address, or as the tool's `value` only for a value the person already put in the conversation, since a host may record a tool's arguments in its transcript. A call that passes `generate` and an application has the platform create the value in custody and returns none. A call with no `value` and no `generate`, through a tool or on that route under a bearer credential of your own, stores nothing. It returns four command forms. `command_npx` sends the value from this computer under a short-lived grant; `command_npx_windows` is its Windows form. `command` and `command_windows` use the installed turnzero command. The turnzero command reads the value from the file `value_file` gives or at a terminal, never from its command line, and prints neither the value nor the grant. With `replace: true` it replaces a stored value: Replace a named value without a code change. The new value travels as a `POST` to this action's address with `replace: true`, or as the tool's `value`, for a value the person already put in the conversation. A call with a name of your own and no `value`, through a tool or on that route under a bearer credential of your own, rotates nothing. It returns four command forms. `command_npx` sends the new value from this computer under a short-lived grant; `command_npx_windows` is its Windows form. `command` and `command_windows` use the installed turnzero command. Where the running copy of the rotated scope's environment carries a binding of the name, that answer's `next` gives the `restart_application` call to make once the command ends 0. A write carrying `value` under a bearer credential of your own on the HTTP action route and passing `restart` true starts that restart itself, its outcome returned as `restart`, and `wait_seconds`, up to 45, beside it holds that answer until the restart ends. A line's write under its grant, and a browser-session write, never does. The write's answer, which the command prints, gives that environment as `restart_environment`, whose copy keeps the previous value until a `restart_application` of it.",
      "owners": [
        "SCRT-L0-08",
        "SEC-L0-07",
        "MAPI-08",
        "SCRT-L0-02",
        "SEC-L0-20"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "list_secrets",
      "resource": "secret",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The custody index: names, scopes, and stamps - never values.",
      "owners": [
        "SCRT-03"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "delete_secret",
      "resource": "secret",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "End one stored value through the pending action, its description rendered from the custody index: the entry leaves the index and no caller reads the value again, the vault holding it in its soft delete for its retention window. A platform-minted name, and a name a binding, an upstream, a realm route, or a push provider uses, is refused.",
      "owners": [
        "SCRT-L0-07",
        "SEC-L0-07",
        "API-L0-07",
        "MAPI-05",
        "MAN-14"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "mint_token",
      "resource": "token",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud"
      ],
      "summary": "Mint a token from the connected session: its scope (the account, or one application), an optional expiry and label, and the grants requested, each given only where the session holds it. The space grant `issues`, given by any session of the account, takes one space the account holds in `space` and the `level` it reaches it at, `report`, `contribute`, or `owner`. Its `label` is required and identifies the holder. Every call passes `code_challenge`, the S256 challenge of the verifier the turnzero command keeps, which the command prints and `login` carries to its page. The call returns a one-time token code's line and no value, or, with `authorized_computer` true, the held line `turnzero authorize --mint <id>`, which holds no code. A mint whose grants are `[\"tzmesh\"]` alone may pass `completion` too, its held line `turnzero tzmesh register --mint <id>`. The command's exchange under that code, on the HTTP action route with `code_verifier`, or under the verifier with `mint` for the held line, returns the value once, and a call that passes no challenge is refused `invalid_request`. A token carrying `issues` is minted only for an account holding tzTrack, and otherwise refused `blueprint_required` with nothing minted. A token carrying `tzmesh`, given by any session of an account holding that product profile with a `label` and no `level`, is refused `tzmesh_required` where the account lacks it. A token carrying `tztrack`, given by any session of an account holding that product profile with a `label` and no `level`, is refused `blueprint_required` where the account lacks it; a `tzmesh` or `tztrack` token lives at most 180 days, 180 where `expires_in_days` is absent, and its value is the signed form its product's service verifies. A token carrying `test_end_users`, given by any session of the account on an account or an application token, takes a `label` for the holder, unique among the unrevoked tokens carrying it in its scope, lives at most 180 days, 180 where `expires_in_days` is absent, and is refused beside a narrow grant and on an authorized computer's mint; it admits test end users wherever the account's session is admitted.",
      "owners": [
        "API-L0-05",
        "API-L0-17",
        "MAPI-12",
        "MAPI-14"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": false
      }
    },
    {
      "name": "revoke_token",
      "resource": "token",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "End one minted token by its identity; every later presentation is refused. With `connection` it ends a connection: End one connection by its id: its refresh and its access token are refused at once, and every other connection remains.",
      "owners": [
        "API-L0-05",
        "MAPI-14",
        "WEB-L0-21",
        "ACS-L0-11",
        "MCP-10",
        "API-L0-21",
        "MAPI-19"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "list_tokens",
      "resource": "token",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "admits": [
        "synthetic_estate",
        "issues",
        "tzmesh",
        "tztrack"
      ],
      "summary": "The account's minted tokens: identities, scopes, grants, labels, stamps, and a space grant's space and level, and `authorized_computer`, true on an authorized computer's token, never values. If no narrow grant bounds the credential, it also returns the account's live connections. Each row gives the tool's refresh family, client, sign-in, last renewal and expiry, never a token.",
      "owners": [
        "API-L0-05",
        "MAPI-14",
        "WEB-L0-21",
        "ACS-L0-11",
        "MCP-10",
        "API-L0-21",
        "MAPI-19"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "declare_storage_area",
      "resource": "area",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Declare or re-declare a storage area: the three minting declarations — whether files are keyed by end user, whether earlier versions are kept, and the one application of the account the area binds to, required under the account's own credential — idempotent on identical declarations, refused on differing ones; versionKeeping true refuses at v0. The manifest's `object_storage` entry may instead list the area in `areas`, and each submission then declares it for that application, so neither this action nor `mintArea` is needed. With `remove: true` and `name` alone, an area holding no file in either environment partition is undeclared, which frees its name for a new area; an area holding a file refuses `area_not_empty`, and an absent name returns `unchanged`. A file is uploaded from a shell under a single-use grant that mint_upload_grant returns, with a ready command; in Windows PowerShell, Invoke-WebRequest needs -UseBasicParsing.",
      "owners": [
        "STO-01",
        "OST-L0-01",
        "OST-L0-03",
        "OST-L0-08"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "list_storage_areas",
      "resource": "area",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The account's declared storage areas with their declarations.",
      "owners": [
        "OST-L0-01"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "list_storage_files",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzop"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "listing": "admitted",
      "summary": "List one page of files in a declared storage area bound to the given application. `environment` selects the partition, by default the application's deploy target, where an upload with no environment writes; `prefix` keeps the files whose name starts with it.\n\nEach file gives its name, size, content type, creation and last-write times, acting identity and version, with no content. The storage listing's page bound applies. The action and the file listing route accept each other's cursors for the same listing. An undeclared area refuses `undeclared_area`, another application's or the platform's deploy area `area_scope_refused`, and a cursor for another listing `invalid_cursor`.",
      "owners": [
        "OST-L0-02",
        "OST-L0-03",
        "OST-L0-04",
        "OST-L0-05",
        "OST-L0-07",
        "API-L0-17",
        "WEB-L0-17"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_storage_file",
      "resource": "environment",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzop"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "listing": "admitted",
      "summary": "Read one stored file's fields in a declared area bound to the given application. `environment` selects the partition, by default the application's deploy target, where an upload with no environment writes. The fields are its name, size, content type, creation and last-write times, acting identity and version, the storage metadata read's ETag. No content is returned; download through the storage routes. An absent file refuses `no_such_file`, an undeclared area `undeclared_area`, and another application's or the platform's deploy area `area_scope_refused`.",
      "owners": [
        "OST-L0-02",
        "OST-L0-03",
        "OST-L0-05",
        "OST-L0-07",
        "STO-04",
        "API-L0-17",
        "WEB-L0-17"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "mint_upload_grant",
      "resource": "environment",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Mint an upload grant for one file of a declared storage area bound to the named application: a single-use bearer credential for one PUT of that file, expiring after the configured lifetime, five minutes by default. It is admitted to the credentials `deploy` admits for that application, a deploy upload's grant aside, and the application's platform credential is refused. The file goes to the partition `environment` gives, or, where it gives none, to that of the environment the application's deploys go to; the write records the identity deploy unless `identity` gives another.\n\nThe answer carries the grant once, its expiry, the size it admits, and the file's whole address. Where the file's name allows them, it also returns four command forms. `command_npx` uploads the file with turnzero's `put`; `command_npx_windows` is its Windows form. `command` and `command_windows` use the installed turnzero command. An optional `local_path` is the file the command reads. A path outside its allowed form is refused `invalid_request`, so no grant is minted. Where the file's name holds a character a command cannot carry alike in every shell, none of the four command forms is returned. Two ready commands are returned either way: `curl` for a POSIX shell, and Windows PowerShell's `Invoke-WebRequest -UseBasicParsing`, each sending the grant as the bearer and no other header. The one write that lands spends the grant, and every other route refuses it.\n\nWith no shell, get the page's address from `read_status`'s `dashboard`, passing `brief: false`. Ask your user to open it after signing in and use Upload a file; do not call this tool for that upload.",
      "owners": [
        "OST-L0-08",
        "OST-L0-03",
        "OST-L0-02",
        "OST-L0-04",
        "API-L0-17",
        "SEC-L0-07",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": false
      }
    },
    {
      "name": "declare_outbound_api",
      "resource": "upstream",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Declare or revise an upstream: base URL, custody credential name, auth form, and the optional `sdk_settings`; the tier noted for its credential-binding weight. With `remove: true` and `name` alone, it ends one declaration instead: the declaration is removed and the name freed, and the upstream's egress keys end in both environments; a call that fails ends nothing. The gateways then refuse its calls from any running copy once their short cache interval passes. The stored key stays in custody, and delete_secret is then admitted where nothing else refers to it. A removal of an upstream the bound application's manifest lists in `upstreams` is refused `manifest_owned_field`: remove the entry, submit the manifest, and promote the version that no longer calls the upstream first. No submission ends an upstream, and for an absent name the removal returns unchanged. The route for every external API an application calls on a stored key: the value goes into custody under the name first (`store_secret`), and the gateway applies it at its own edge. The gateway never gives the key to the application, though an upstream that echoes the key returns it. With `sdk_settings`, each deploy, promote, and restart sets the named base-URL setting to the gateway's route and the key setting to an egress key the gateway swaps for the stored key, so an unchanged SDK reaches the API. A stored name a setting binds, in the manifest's `settings`, in either environment's running copy, or in an act in flight, is refused `upstream_key_is_bound`. An upstream that the bound application's manifest lists in `upstreams` belongs to the manifest, and a change to it is refused `manifest_owned_field`. The declaration is recorded in the project's own requirements, the platform's example applications showing one form that works, reached through the served library-first guide.",
      "owners": [
        "EGW-L0-01",
        "EGW-L0-02",
        "EGW-L0-03",
        "EGW-L0-07",
        "EGW-L0-08",
        "SEC-L0-18",
        "MAN-14"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "list_outbound_apis",
      "resource": "upstream",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "The account's declared upstreams, with the latest eligible upstream call for each declaration when available.",
      "owners": [
        "EGW-L0-01",
        "EGW-L0-09"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "approve_pending_action",
      "resource": "pending_action",
      "tier": "destructive",
      "surface": "account",
      "addresses": [],
      "clients": [
        "browser_session"
      ],
      "summary": "The one completing action: you approve the platform's description in your browser while signed in. An AI tool never calls it.",
      "owners": [
        "WEB-L0-13",
        "API-L0-07"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "read_approval_status",
      "resource": "pending_action",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "admits": [
        "device_sign_in"
      ],
      "summary": "The requesting credential reads the record and its outcome — how the interface reports what the browser decided.",
      "owners": [
        "MAPI-05",
        "CHI-L0-10"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_library",
      "resource": "library",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "access": "anonymous",
      "summary": "The library's inventory: catalog rows and their selection summaries, served to any connected identity, and on the wire to a request carrying a credential of an account. With `entry` it reads one entry: One published entry: its file list with a hash and a size per file, or one named file's content, whole or, with `offset`, `limit`, and `stamp`, in chunks on the served context's paging, the stamp the file's hash and a stale one refused context_changed. It is served to any connected identity, and on the wire to a request carrying a credential of an account, like the inventory beside it. A tool reads a package's test double, `lib/testing.js`, here with no token for the take line. Latest only: a publish replaces what is served, and a consumer keeps its own copy of what it holds.",
      "owners": [
        "API-L0-15",
        "MAPI-11",
        "LC-06",
        "API-L0-14",
        "LC-04",
        "LC-05",
        "CTX-07"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "configure_app_sign_in",
      "resource": "realm",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Set a realm's enabled sign-in methods, whether creation is open or invitation-only, the creation ceiling, the per-source sign-in rate, the session lifetime with the cap on a native session's sliding life, and the native clients it declares; refused by name for an application whose manifest declares no accounts service, for sign-in methods contradicting the declared audience, or for a redirect URI outside the admitted forms; with no application member the builder realm's creation mode, its creation ceiling, and its site_public member alone, admitted to super_admin alone. Raising a client's minimum version returns a warning listing the versions seen within the last day that the new minimum refuses.",
      "owners": [
        "ACS-L0-07",
        "ACS-L0-12",
        "ADM-L0-05",
        "ACB-L0-77",
        "ACB-L0-80",
        "ACS-L0-05",
        "ACS-L0-09",
        "PLD-L0-40",
        "ACS-L0-15"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "read_app_sign_in",
      "resource": "realm",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "A realm's configuration, its declared native clients with the versions each stated within the last day, and its user and session counts with its secret names, never a value.",
      "owners": [
        "ACS-L0-07",
        "PLD-L0-40",
        "ACS-L0-15",
        "ACS-L0-09"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "check_app_sign_in",
      "resource": "realm",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Check a realm's work-account and Apple sign-in routes with no one signing in: for each, whether its stored credential reads, the provider token endpoint's test response, and whether the realm's sign-in page offers the route.",
      "owners": [
        "MAPI-30",
        "ACS-L0-24",
        "PLD-L0-67"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": true
      }
    },
    {
      "name": "configure_push",
      "resource": "push",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Set an application environment's push providers — Apple's team, key, bundle, gateway, and stored signing-key name; Google's project and stored service-account file name — each optional, null removing one; refused by name where the manifest declares no push service, where a named secret is not in custody at that scope, or where the name is an upstream's or a realm route's credential or a setting binds it.",
      "owners": [
        "PSH-L0-01",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "read_push",
      "resource": "push",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "An application environment's push configuration with secret names only, its device counts by platform, the last hour's delivery outcomes, and the month's accepted deliveries beside the size's quantity, the same for both sizes.",
      "owners": [
        "PSH-L0-01",
        "PSH-L0-02",
        "PSH-L0-04",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "list_end_users",
      "resource": "realm",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Each end user's opaque identifier, creation stamp, standing, routes, and provider-verified or tenant-asserted address, paged.",
      "owners": [
        "ACS-L0-08",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "set_end_user_standing",
      "resource": "realm",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Set one end user's standing: `suspended` ends every session at once and refuses the next sign-in by name until a call sets `active`, which restores the standing and leaves the ended sessions ended.",
      "owners": [
        "ACS-L0-08",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "revoke_app_sign_in_keys",
      "resource": "realm",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Revoke every signing key of one realm: every session token the keys signed is refused as key_revoked once the routers sync, every user signs in again, and the accounts service mints the replacement at the next sign-in.",
      "owners": [
        "ACS-L0-08",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "delete_end_user",
      "resource": "realm",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Remove one end user's rows through the pending action, its description rendered from the platform's own record.",
      "owners": [
        "ACS-L0-08",
        "API-L0-07",
        "MAPI-05",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "invite_end_user",
      "resource": "realm",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Issue or revoke one invitation of a realm. A call with `email` mints one single-use invitation URL for that address, expiring after the configured interval. A call with `invitation` ends that invitation before its redemption by stamping it revoked; a revoked invitation is refused at redemption as an unrecognized invitation. With no application member either form is the builder realm's, admitted to super_admin alone. A builder invitation lists in `products` the product profiles its redemption adds — `tzcloud` alone if omitted, `tzteam` beside it for tzTeam access. They go to the account it creates or to the existing account whose sign-in redeems it.",
      "owners": [
        "ACS-L0-08",
        "ACC-L0-24",
        "ACB-L0-77",
        "PLD-L0-40",
        "ACB-L0-76"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "read_schedules",
      "resource": "application",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "An application's declared schedules for an environment. Each carries its next due time in UTC, the run in flight, the last run, and the most recent runs with outcome, status, and duration. Each also says whether the environment holds a deploy or promote made at or after the declaration: for production, the deploy on one environment and the promote on two. A declaration whose environment has none returns `deployed: false` with the reason: no deploy, or a declaration awaiting one. Each also carries `cron_preview`, up to three instants its cron yields; for a deployed row in an environment that is not halted, those are the due times the platform claims in turn, a claim late inside the tolerance passing due times over. With `wait_seconds` (1 to 45), the answer is held until no run of the environment is in flight, and it carries `settled` and `waited_ms`.",
      "owners": [
        "SVC-L0-15",
        "PLD-L0-40",
        "SCH-L0-06",
        "MAPI-04"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "run_schedule",
      "resource": "application",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Fire one declared schedule now as a manual run: it returns `running` at once, and you read the run back through `read_schedules`. It is refused `run_in_flight` while the schedule's last run is still running. It is refused `schedule_not_deployed` until the environment has a deploy or promote made since the schedule was declared: for production, the deploy on one environment and the promote on two. A retry with the same `request_id` returns the same run. It is refused `target_environment_halted` too, where the environment is halted. With `wait_seconds` (1 to 45), the answer is held until the run ends, and it carries `settled` and `waited_ms`. With or without the wait, it carries `next` while the run is still running. Settled, it also carries the run's console lines in `console`, at most 40, with `more` giving the `read_logs` call for any it left out.\n\nAn answer that is not this platform's own, such as a gateway's error page or a closed connection, says nothing about whether the run started. Read `read_schedules` first, and repeat the call only with the same `request_id`, which returns the run the first call started, or starts it where the first call did not.",
      "owners": [
        "SVC-L0-15",
        "MAPI-04",
        "SCH-L0-06",
        "PLD-L0-41"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "list_invitations",
      "resource": "realm",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Each invitation of a realm, paged in issue order, never a URL or its token. Each row holds the identifier `invite_end_user` returned at the issue, the address, and the issue, expiry, redemption, and revocation stamps. It also holds the user a redemption created or the existing account that redeemed it, and the state those decide. With no application member it lists the builder realm's, admitted to super_admin alone, each row then carrying `products`, the profiles its redemption adds.",
      "owners": [
        "ACS-L0-08",
        "ACC-L0-23",
        "ACB-L0-77",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "add_test_end_users",
      "resource": "realm",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Create or remove the test end users of one realm of your account's own application. A call with `labels` makes up to twenty, `application` and `environment` both required. Each is a user row holding one verified `email` identity `<label>@synthetic.turnzero.ai`, expiring 48 hours after its creation, and counted as no user. It signs in through the realm's own emailed-code route, its code held for `read_test_signin_code` and never sent. For a label an unexpired test end user of the realm holds, the call returns that user unchanged with `created` false, so a retry creates nothing. A label whose row has expired is removed and created afresh. It admits the account's session and a token carrying `test_end_users` on every realm. On a production realm, and on a workforce application's realm, it refuses any other minted token `test_end_users_not_admitted`. Each creation there writes one info line with the application, the environment, the count, and the credential, and no address. Refused `test_end_users_ceiling_reached` past twenty unexpired test end users on the realm or fifty created by the application's realms within the hour. Refused `not_test_end_user` for a label whose address another end user of the realm holds, and `test_end_users_disabled` while the control plane's `TEST_END_USERS` setting reads `off`. `remove: true` removes test end users at once, with no pending action, `application` and `environment` both required and either `end_users` or `all` true: each removal ends the user's rows, identities, and sessions, writes the user revocation row the routers sync, deletes the user's held codes, and takes the live tickets they were started under. Refused whole `not_test_end_user` where any named user is not a test end user of the realm. A removal is admitted while `TEST_END_USERS` reads `off`, so an operator's stop strands no test end user.",
      "owners": [
        "ACS-L0-21",
        "ACS-L0-20",
        "PLD-L0-40",
        "ACS-L0-06"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "read_test_signin_code",
      "resource": "realm",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Read the unspent emailed sign-in codes held for one test end user of one realm of your account's own application, by `end_user` or `email`, `application` and `environment` both required. They come newest first, each with its issued and expiry instants, its binding hash, and the attempts remaining. Where `binding` gives your own binding hash (base64url of the SHA-256 of the binding cookie's value), you get that one ticket's code alone. Admitted to the account's session, its account-wide token, or a token bounded to that application and to no other credential, `super_admin` widening it to no other account's application. On a production realm, and on a workforce application's realm, it admits the session and a token carrying `test_end_users`, any other minted token refused `test_end_users_not_admitted`. Refused `not_test_end_user` for a user who is not an unexpired test end user of the realm; readable while `TEST_END_USERS` reads `off`, every read one action record, and no code reaching any record.",
      "owners": [
        "ACS-L0-21",
        "ACS-L0-20",
        "ACS-L0-12",
        "PLD-L0-40"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "sign_in_test_end_user",
      "resource": "realm",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Sign one test end user of one realm of your account's own application in for the turnzero command, `application`, `environment`, and `end_user` all required, the user by its identifier or its label. A tool's call, and any call without `delivery`, returns the command `turnzero session` in its four forms: run once, it signs the user in and writes the session's cookie into a cookie jar file `curl -b` reads, so the value passes through no tool. The turnzero command's own call on the HTTP action route, with `delivery` as `command`, returns the session: the hostname, the end user, `expires_at`, and the cookie's name and value, with no cookie set on the response. The session lasts one hour, or until the test end user's expiry, or the realm token's life where shorter. Admitted as `read_test_signin_code` is: the account's session, its account-wide token, or a token bounded to that application, `super_admin` widening it to no other account's application. The command is returned to the account's session and a token carrying `test_end_users` on every realm. On a production realm, and on a workforce application's realm, the command's detail says its token needs the grant. There a minted token without it is refused `test_end_users_not_admitted`, at the call and on the command route. Refused `local_route_required` where `delivery` reaches any surface but the HTTP action route, `not_test_end_user` for a user who is not an unexpired test end user, `test_end_users_disabled` while `TEST_END_USERS` reads `off`, and `command_too_old` on the command route below turnzero 0.37.0. The command route is also refused `signin_code_rate_limited` past the address's hourly starts, and `signin_code_invalid` or `user_suspended` from the confirmation. Every call is one action record, and no record carries the cookie's value.",
      "owners": [
        "ACS-L0-21",
        "ACS-L0-20",
        "ACS-L0-12",
        "PLD-L0-94"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": false
      }
    },
    {
      "name": "read_context",
      "resource": "platform_context",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "admits": [
        "device_sign_in"
      ],
      "access": "anonymous",
      "summary": "Read a catalog content ID. Follow next_offset with its stamp to read the complete contracts, guide or live skill text. With no `id` it returns the catalog: List the platform context catalog, including contracts, guides, tzCloud's own skills and available documentation trees. The catalog lists no skills from other products. Start here to discover what to read.",
      "owners": [
        "CTX-07"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "read_documentation",
      "resource": "platform_context",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools",
        "tzop"
      ],
      "admits": [
        "device_sign_in"
      ],
      "summary": "Read a documentation tree this connection's account holds, chosen by tree or by the base path of the page route: cloud and tzdocs for every account, tzteam for an account holding tzTeam access, tzmesh for an account holding tzmesh, and tztrack for an account holding tzTrack. It reads the tree's index by default. With page it reads one page by its route, with page and section one section of it, and with page and query that page's matching lines. With part outline it reads the index with every page's headings, or with page that page's alone, and with part full the whole text. Follow next_offset with its stamp for the complete text. For a long page, pass the section a search hit gives as section, or start at a section by the offset its first chunk's headings lists, with that chunk's stamp. To find a page by its words, call search_documentation.",
      "owners": [
        "CTX-07",
        "CTX-09",
        "ACB-L0-82",
        "PLD-L0-69",
        "CTX-05"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "search_documentation",
      "resource": "platform_context",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "summary": "Search the documentation for a few words and get the best matching sections, best first: each hit's tree, page title, route, section heading and anchor, excerpt, and score, and the same hits as Markdown lines. With a credential it searches every tree the account holds, or the one given as tree. With no credential, on the wire at its own address by GET or POST, it searches the documentation open to everyone, as the website's search box does.",
      "owners": [
        "CTX-10",
        "CTX-09",
        "ACB-L0-82",
        "API-L0-15"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "rename_application",
      "resource": "application",
      "tier": "destructive",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Rename one application: the readable name changes and a new hostname label is minted for it, the previous label retired for good. It completes through the pending action a person approves, whose description gives the previous hostname, the new name, and the end-user consequences.",
      "owners": [
        "SVC-L0-07",
        "API-L0-07",
        "MAPI-05"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": true
      }
    },
    {
      "name": "read_plan_quotas",
      "resource": "account",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "clients": [
        "bearer",
        "browser_session"
      ],
      "summary": "Return the served quantities of the selected sizes, or the sizes' rows where neither `plan` nor `measure` is passed. For each size the rows are the enforced entries, then its served values. Each row gives its unit, and with `stamps: true` its stamp and author. Any signed-in credential can read them, an application-bounded token included. No application at that size is needed.\n\nWhere the credential and account bypass the application limit, `application_limit_exemption` gives the exemption.",
      "owners": [
        "PRC-L0-16",
        "API-L0-17",
        "ACB-L0-84"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "submit_feedback",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "admits": [
        "synthetic_estate",
        "tzmesh",
        "tztrack",
        "device_sign_in"
      ],
      "summary": "File a report into the platform's own space of the issue service as your own actor, under any bearer or account-scoped minted token, a token the synthetic_estate grant bounds among them. `source` gives the actor's kind, `person`, `agent`, or `system`, and an agent also gives its `provider` and `session`; under a minted token, `person` is written as `agent`. `kind` is one of the record's eight kinds, `idea` among them, or a word still accepted for one, `problem`, `error`, and `mistake` for a `bug` among them. The report comes with a `title`, an optional `text` (or `body`), `impact` (or `severity`), `workaround`, `proposed_resolution`, `labels`, `restricted`, and an `evidence` member. That member gives the action, the refusal, and the reference the report is about. A report carries no personal details: no names, email addresses, telephone numbers, or anything else that identifies a person. Where the reference identifies one of your own refused calls, the platform stamps the action, the refusal, the code site, and the build from its own record on either of two grounds. The kind is `bug`; or the impact is `blocked`, the kind is neither `praise` nor `idea`, and the action is one of the target space's `critical_actions`. It then marks the evidence stamped. Where that call was not refused, it writes the action and the build and leaves the evidence as claimed. A report about a refused call that meets neither ground also carries the refusal, still claimed and with no code site. `problem_key` (or `key`) identifies the problem among your own reports, a repeat with new evidence filing a new report linked to the same issue. Praise and a report of another kind under one key are filed on two issues. The answer carries your own report, the issue through the projection, the outcome (`filed`, `linked`, `retried`, `noted`, `confirmed`, `related`, or `amended`), up to three candidates it may be repeating, and the credential forms masked in its text. `repeat_of` beside a filing, or `report` with `repeat_of` alone, confirms a candidate. Across the praise kind it links nothing and the outcome reads `related`. `amends`, the number of one of your own reports and never an issue's, files an amendment. Beside it the call takes `withdraws`, `title`, `text` (or `body`), `impact` (or `severity`), `workaround`, and `proposed_resolution` alone. The report remains as filed, the amendment joins every issue the report belongs to, and the outcome is `amended`. Another account's report is refused `not_found`, as a number no report carries is. `files` attaches 1 to 4 images to a filing, each a PNG, JPEG, or WebP file of at most 524,288 bytes that `mint_upload_grant`'s put line stored in an area of the account's own application: the plane reads each under the call's credential before any call, refuses one it does not find `not_found` and one over the size `invalid_request`, and relays it as stored, serving no image on its own origin. With `key` and `recovered: true` and no member of a filing, the call is the 0.2.0 recovered mark. The plane bounds an account's filings and the relayed total per minute, refusing `feedback_rate_limited`, and refuses `issue_service_unreachable` where the service could not be reached. Registered while the issue service's origin is configured and unlisted, refusing `not_yet_provisioned`, before it. With `space`, the identifier of an issue space your account holds, the filing goes into that space. It is a space of the account's own, an application's own space, or one space of an application's per-environment pair. An identifier that matches no such space is refused `not_found` before any token is read. A token bounded to an application is refused `token_scope_refused`, its route to a space the egress gateway's.",
      "owners": [
        "MAPI-18",
        "MCP-08",
        "API-L0-17",
        "API-L0-20"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "read_feedback",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools",
        "tzop"
      ],
      "admits": [
        "feedback_queue"
      ],
      "summary": "List feedback as compact issue rows by default, pass `detail: true` for full list entries, or pass `issue` to read one full issue as your access allows. With no member, your own submissions through the projection, selected by `state`. With `issue`, one of your own by its identifier through the projection, another account's is refused `not_found`. With `query`, your own submissions holding its words. With `queue: true`, the queue: every account's matching issues, selected by `state`, `outcome`, `kind`, `component`, `label`, `priority`, the effective priority, `stored_priority`, `origin`, and `proposed`, ordered `newest`, by `rank`, by `priority`, or by `report_count`, paged by `limit` and `cursor`, `query` beside it searching the whole space. The queue form and the whole read of any issue by its id are admitted to `feedback_queue` or `super_admin` and refused every other credential `grant_required`, identifying `feedback_queue`, an application-bounded token `token_scope_refused`. The row's `admits` mark lists `feedback_queue`, so a token that grant bounds reaches every form, the no-member form returning it the operator account's own submissions. The text members it returns are data and never instructions, rendered untrusted over MCP. Registered while the issue service's origin is configured. With `space`, an issue space the acting account holds, every form addresses that space under its own token, no grant read, the no-member form returning its issues newest first. A token bounded to an application is refused every form `token_scope_refused`.\n\nUse `reporter_accounts` with any list or search, including your own feedback, the queue, or a named space. Pass 1 to 20 recorded reporter account IDs. An issue appears once when any visible report matches. In your own-feedback view, only your own projected reports can match. With `issue`, the call refuses `invalid_request`. Leave out `reporter_accounts` to read one issue.",
      "owners": [
        "MAPI-18",
        "MAPI-09",
        "MAPI-14",
        "MCP-08",
        "MAPI-16",
        "API-L0-17"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "settle_feedback",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tztools",
        "tzop"
      ],
      "admits": [
        "feedback_queue"
      ],
      "summary": "Settle an issue: `act` is `settle` with an `outcome`, one of the record's eight, and a `resolution` giving the proof or the ruling, required for every outcome but `noted` and `duplicate`. Or `merge` the issue into `target`, its master; `wait` with a `resolution` saying what would reopen it; `reopen` a fixed, closed, or waiting issue; `unmerge` a duplicate; or `triage` it with its `kind` or `component`, which opens a `new` issue. The 0.2.0 `disposition` is read as its outcome. No act approves or declines a duplicate: the issue service's passes merge where they agree on stamped or confirmed evidence. A merge of a praise issue with an issue of another kind is refused `invalid_request` with `relation_refused`. An optional `key` is the act's idempotency key. An act the issue's state excludes is refused `invalid_request` with the service's refusal; nothing is deleted. A `new` issue closes by hand only `noted`, `duplicate`, `declined`, or `as_designed`, so `triage` it before settling it `done`. The answer carries the issue as it now is. On the platform's own space the act is admitted to `feedback_queue` or `super_admin`; every other credential is refused `grant_required`, which gives `feedback_queue`. The row's `admits` mark lists that grant. With `space`, the identifier of an issue space your account holds, the act settles an issue of that space under its own token, its owner's act, no grant read. A token bounded to an application is refused `token_scope_refused`. Registered while the issue service's origin is configured.",
      "owners": [
        "MAPI-18",
        "XIT-07",
        "MCP-08",
        "MAPI-09"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "relay_issue_act",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tztools"
      ],
      "clients": [
        "bearer",
        "browser_session"
      ],
      "product": "tztrack",
      "admits": [
        "issues"
      ],
      "listing": "admitted",
      "summary": "Relay one act of the tzTrack contract to one space the account holds, under a token the `issues` grant bounds to that space. `space` picks the space, and `act` the act, one of submit, follow, list, search, read, attachment, update, comment, relate, settle, reopen, unmerge, next, give_back, wait, watch, unwatch, land, deploy, ship, check, configure, export, count, rates, read_space, and cache. `body` is the act's request as the contract states it, less the actor. The platform gives the actor as the account's, qualified by the token's label, with `source` giving its kind. The token's level admits the acts: `report` files, follows, checks, and reads; `contribute` also works issues and asks `cache` for a link to the space's archive; `owner` reaches every act, the space's `count`, `rates`, and `read_space` among them. `report` also sets and removes a watcher of an issue, with `watch` and `unwatch`. `contribute` also settles a task with any outcome except `duplicate` and reopens a task. Settling or reopening another kind, and every `unmerge`, require `owner`. A credential holding `super_admin` passes the grant's gate at the owner's level. A read carries no reading actor. At the `owner` level it returns the space whole. At the `contribute` level a `list` or a `read` returns a restricted issue as any other. At the `report` level a `list` or a `search` returns no restricted issue, and a `read` of one is refused as a read of an absent issue is. There a `read` returns its `proposals` less each one marked `restricted`. At that level an `attachment` returns an image only where the service reports its issue unrestricted, any other refused as an image that does not exist. An `attachment` returns `{ media_type, content }`, the image's media type and its bytes in base64url, and a `submit` and a `comment` carry `attachments` as the contract states them. Below the `owner` level a filing takes the origin `field` from the platform, and an `update` whose fields set `restricted` to any value but `true` is refused `issues_level_refused` before any call. At the `report` level a writing act that identifies a restricted issue is refused as one that identifies no issue is, and an answer that would hold one carries a null `issue`. A `watch` passes the token's level to the service, so a watcher set at `report` is deleted at the first change of its issue while the issue is restricted. A `read` returns `watchers`, the count of the issue's standing watchers. A `submit` gives where the problem was found in `seen_in`, each build `{ release_line, version, environment }`, a repository commit as its version. Its evidence is forwarded `claimed`, never `stamped`. A `seen_in` outside that shape, or a body that marks its evidence `stamped`, is refused `invalid_request`. A `configure` sets `components`, `release_lines`, `credential_forms`, `personal_forms`, `automation`, `critical_actions`, and among the constants `report_text_retention_days`, `priority_boost_report_threshold`, `priority_boost_window_days`, `max_counted_reports_per_account`, and `internal_report_ranking_weight`. Any other member or constant is refused `invalid_request` by its name before any call. A stored member or constant name is refused `invalid_request` before any call. The service's detail gives the stored name, its 0.3.0 name and the edit. A constant this action refuses is refused under its 0.3.0 name even if it or a nested member uses a stored name. That refusal gives no rename detail. On the platform's own space a `configure` the `owner` level or `super_admin` would reach is refused `platform_space_configure_refused`, the platform's operator configuring that space. A credential holding no space grant is refused `grant_required`, which gives `issues`. For an account that holds the tzTrack profile the relay needs, a space other than its grant's, or one the account neither has nor is a member of, is refused `space_not_owned` whatever the credential. An act outside the level is refused `issues_level_refused`. Where the service refuses the act for its content or its state, the call is refused `issue_refused`, which gives the service's own refusal. An account that does not hold tzTrack is refused `blueprint_required` on every call, ahead of the form, the space, and the level, whatever kind of space it addresses. Each token's calls and each space's calls are bounded per minute, refused `feedback_rate_limited`. The answer carries the space, the act, and the service's answer as `result`. Registered while the issue service's origin is configured.\n\nFor `list` and `search`, put `reporter_accounts` in `body`. It matches 1 to 20 recorded reporter account IDs within the caller's existing read scope. The plane refuses `relayed_account`, `relayed_level`, and `projection_accounts` in `body`.",
      "owners": [
        "MAPI-14",
        "MAPI-16",
        "MAPI-18",
        "API-L0-20",
        "ITS-L0-05",
        "ACB-L0-92"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "create_space",
      "resource": "account",
      "tier": "reversible",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "product": "tztrack",
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "Create an issue space the account holds at the issue service, the space a repository's issue list or a program's checks live in: the optional `space` is a lower-case UUID you choose, so retries reuse that space, and absent, the platform chooses one. The required `name`, 1 to 100 printable characters and refused `invalid_request` when absent or outside that, is the space's display name, written only when the call first records the space for the account: a repeat finding the space recorded keeps the name it has, and a retry after a lost answer still writes it. The space's own token stays in the platform's vault; a program reaches the space through `relay_issue_act` under a token minted with the `issues` grant for it. The answer carries the space's identifier, whether this call created it, and the space's display name, null where it has none. The account must hold tzTrack, refused `blueprint_required` ahead of the request's form and the bounds where it does not. Bounded per account per minute, refused `feedback_rate_limited`; `issue_service_unreachable` where the service or the platform's provisioning credential could not be reached. Registered while the issue service's origin is configured.",
      "owners": [
        "MAPI-14",
        "API-L0-20"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "list_issue_spaces",
      "resource": "account",
      "tier": "observe",
      "surface": "account",
      "addresses": [
        "tztools"
      ],
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "List the issue spaces the account holds, oldest first: each space's identifier, kind, `name`, and creation instant. For the account's own and shared spaces, `name` is the owner's given name, or null where none was given. For an application's own space it is the application's name; for the platform's own space, `Turn Zero feedback`. Over MCP the answer is rendered inside the untrusted block, since a shared space's name is another account's text.\n\nThe kind is `account` for a space the account created, `application` for an application's own space, or `member` for one another account shared. An application's entry also gives its `application`. A member's entry gives its `level` and `owner`. It gives effective restricted-issue access, and where bounded its `accounts` and `actions` cut to the bounded-call list.\n\nThe platform's own space comes last, kind `platform`, for its owner and for an account the operator granted a row there. A granted account gets its row's level and role, `restricted: false`, its `accounts` bound, and bounded `actions` without `configure`; `owner` is null. A space an application holds for one environment is not listed, since no `issues` token reaches it. A token minted with the `issues` grant is limited to one listed space. Registered while the issue service's origin is configured.",
      "owners": [
        "MAPI-14",
        "API-L0-20",
        "ACB-L0-92"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "share_space",
      "resource": "account",
      "tier": "reversible",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "product": "tztrack",
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "Share one issue space the account owns with other accounts, each a member at one level. `space` picks the space. `add` gives an existing account by the email address it signs in with, and `level` sets the member's level in the space: `view`, `report`, `contribute`, or `owner`, defaulting to `contribute`. A repeat updates that member. Use `view` to let a member list, search, and read unrestricted issues and download their attachments. `remove` gives a member by that address. With neither the call is refused `invalid_request`, pointing to `list_space_members`. An address no account signed in with is refused `no_such_account`, and nothing is kept for a later sign-in.\n\nWith `add`, `restricted` is true or false; a new member defaults to false, and omission keeps a standing member's value. Only `contribute` and `owner` can read restricted issues. `accounts` takes null or 1 to 19 distinct account ids; the plane adds the member's own account. A list bounds access to issues holding a report recorded under one of those accounts and excludes every restricted issue, whatever `restricted` says. Null clears the bound; omission keeps the standing value. Either field without `add` is refused `invalid_request`. Rows written before these fields read as before: by level, without an account bound.\n\nA space the account does not own, one shared with it among them, is refused `space_not_owned`; a member never shares, and the feedback actions stay the owner's. An account that does not hold tzTrack is refused `blueprint_required` ahead of the form and the space's ownership.\n\nThe answer carries the members, each with its account, address, level, role, restricted-issue access and the instant it was added. Viewer, Reporter, Contributor and Admin name `view`, `report`, `contribute` and `owner`, respectively. Admin is a member, never the space's owner. A bounded member also has `accounts`, including its own, and reads no restricted issue. It gives `users`, the members plus the owner. Registered while the issue service's origin is configured.",
      "owners": [
        "ITS-L0-07",
        "API-L0-20",
        "ACB-L0-92"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "set_ai_passes",
      "resource": "account",
      "tier": "reversible",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "Turn your issue space's AI passes option on or off. A session changes this option when the account owner requests that change. Otherwise, it leaves the option unchanged. If their choice is missing and nobody can answer, leave it unchanged and report. Turning on charges for the days left in the calendar month. A repeat charges nothing. Turning off gives nothing back. Passes require `ai_reviews_enabled` and either this option on an unpaused account or an unbilled owner. The answer's `on` is the stored option. The issue service takes it on its next account read.\n\nA tzTrack token reaches this act where your tool's sign-in issued it. A token `mint_token` minted is refused `tztrack_bounded`.\n\nName a space your account owns, or a space bound to an application it owns, from `list_issue_spaces`. Each space has its own option. The act does not change `ai_reviews_enabled`; that setting alone runs no passes under usage pricing. Turning on sets the option only after the month's charge is posted or already covered. An unbilled account bypasses the balance check and incurs no real charge.\n\nEvery call before pricing reads usage refuses `invalid_request`, including turning off. The same refusal covers a missing or malformed space id or a missing or non-boolean `on`. `space_not_owned` means neither your account nor its application owns the space; use `list_issue_spaces`. A turn-on refuses `balance_short` where balance left is not more than the month's charge for the days left. `rates_unread` covers unread rate rows or switch instant. `option_not_set` means the option was not turned on, and any posted charge remains. Retry: in the same UTC calendar month, no further charge is posted while the month's charged count covers your AI passes options, including this one.\n\nThe returned `on` and `moved` show what is stored; no further read is needed to confirm the record. Pass eligibility changes when the issue service next reads the account, with no fixed delay promised.",
      "owners": [
        "API-L0-30",
        "ACB-L0-26",
        "ACB-L0-90",
        "ACB-L0-92",
        "ITS-L0-04",
        "PRC-L0-19"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "list_space_members",
      "resource": "account",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "tier": "observe",
      "product": "tztrack",
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "List the members of an issue space you own; pass `space`. Each member has its level, its role (Viewer, Reporter, Contributor or Admin), restricted-issue access and, where bounded, `accounts`, including its own. `users` counts the members plus you; the answer gives your account's tzTrack tier.",
      "owners": [
        "ITS-L0-07",
        "API-L0-20",
        "ACB-L0-92"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "delete_space",
      "resource": "account",
      "tier": "destructive",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "Delete one issue space of the account's own through the pending action: the space at the issue service, its issues, and its daily copies, with no restore. `space` picks the space. The description gives the space's name, its counts where they can be read, its members with their levels, and the applications bound to it, each of whose next deploy needs its manifest's `issue_tracking.space` removed. Approval ends those bindings, deletes the space and its copies, and ends the space's members, its name, and its token. Only the account that owns the space deletes it: a space the account does not own, one shared with it among them, is refused `space_not_owned`, and an application's own space or the platform's own space `invalid_request`. A tzTrack token reaches it where your tool's sign-in issued it, which holds the destructive class; one `mint_token` minted is refused `tztrack_bounded`. For 35 days after the deletion, `create_space` refuses the same identifier. `issue_service_unreachable` where the service or the vault could not be read. Registered while the issue service's origin is configured.",
      "owners": [
        "ITS-L0-01",
        "ITS-L0-06",
        "API-L0-07",
        "MAPI-05",
        "MAPI-18",
        "API-L0-20"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "redact_issue_text",
      "resource": "account",
      "tier": "destructive",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "admits": [
        "tztrack",
        "device_sign_in",
        "issues"
      ],
      "summary": "Redact text spans or remove an image on one issue through a pending action approved in the browser. The request changes nothing. `space`, `issue`, `target` and `ranges` name the current content; ranges are required for text and absent for an image. Approval returns a span count or 1 for an image and the changed issue or report, without text. History retains prior values. The act has no undo; restoring a daily copy taken before it can bring text back. A space's owner and owner-level members can request it. An issues token needs owner level for that space and the destructive class. The AI tool's own tzTrack sign-in and device sign-in are admitted. Other callers are refused `space_not_owned` without revealing whether the space or issue exists. A credential without the destructive class is refused `destructive_class_required`, and a tzTrack token minted by `mint_token` is refused `tztrack_bounded`. Invalid targets or ranges are refused `invalid_request` before any pending action. An unreadable service or vault is refused `issue_service_unreachable`. Registered while the issue service's origin is configured.",
      "owners": [
        "ITS-L0-05",
        "API-L0-06",
        "API-L0-07",
        "MAPI-05",
        "MAPI-12",
        "MAPI-16"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    },
    {
      "name": "rename_space",
      "resource": "account",
      "tier": "reversible",
      "surface": "tztrack",
      "addresses": [
        "tztools"
      ],
      "product": "tztrack",
      "admits": [
        "tztrack",
        "device_sign_in"
      ],
      "summary": "Rename one issue space of the account's own: `space` picks the space, and `name` is its new display name, 1 to 100 printable characters, refused `invalid_request` outside that. The issue service takes the name first, then the platform's own record of it, so `list_issue_spaces` shows it; a space with no name takes one. A failed call of the service changes nothing and is refused `issue_service_unreachable`, and a repeat is safe. Only the account that owns the space renames it: a space the account does not own, one shared with it among them, is refused `space_not_owned`, and an application's own space or the platform's own space `invalid_request`. A tzTrack token reaches it where your tool's sign-in issued it; one `mint_token` minted is refused `tztrack_bounded`. The account must hold tzTrack, refused `blueprint_required` ahead of the request's form. Bounded per account per minute, refused `feedback_rate_limited`. The answer carries the space's identifier, its kind, and its name. Registered while the issue service's origin is configured.",
      "owners": [
        "ITS-L0-01",
        "MAPI-16",
        "MAPI-18",
        "API-L0-20"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "request_export",
      "resource": "application",
      "tier": "reversible",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Export one application's data from one environment: every table of its database written as one CSV file, all tables read under one repeatable-read transaction. A manifest lists each file of the application's other storage areas with its version tag. The platform's deploy area is left out: its one pending zip per environment is no customer file, and it is deleted within a day. The files are written into the application's export area, `export-<application id>`, which the platform mints bound to the application. Returns 202 at once with the export id and the state `running`; `next`, the `read_export` call, reads its progress and then the manifest. A request while an export of the same application and environment runs returns that export. `request_export` with `download: true` returns the command that downloads a completed export's files, which count in the application's stored data until you delete them. `application` is required; `environment` is production if omitted. With `download: true` it returns the download line: Mint a download grant for one completed export of the named application: a short-lived, read-only bearer credential, expiring after the configured lifetime, five minutes by default. It reads, by `GET` of a named file, the export's own files in the export area and the application's stored files in the export's environment that were created by the time the export listed them, the platform's deploy area excepted. A file stored after the export, or deleted and stored again, reads as an absent name does. A fresh export has the application's files as they are now. Where the export recorded no instant for its stored files, the grant reads the export's own files alone, and `detail` says so. It lists nothing, every other route refuses it, and a read does not spend it. It is admitted to the credentials `read_export` admits for that application, and the application's platform credential is refused.\n\nThe answer carries the export, its environment, the grant's expiry, and four command forms. `command_npx` downloads the export with turnzero's `export download`; `command_npx_windows` is its Windows form. `command` and `command_windows` use the installed turnzero command. The grant is returned inside those four lines alone. An optional `local_path` is the folder the command writes into. An export that is running or failed is refused `export_not_completed`, and one whose files no longer exist `not_found`.",
      "owners": [
        "API-L0-18",
        "API-L0-23",
        "MAPI-21",
        "OST-L0-01",
        "OST-L0-08",
        "OST-L0-03",
        "API-L0-17",
        "SEC-L0-07"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": false
      }
    },
    {
      "name": "read_export",
      "resource": "application",
      "tier": "observe",
      "surface": "tzcloud",
      "addresses": [
        "tzcloud"
      ],
      "product": "cloud",
      "summary": "Read an application's export by id, or its latest in `environment` (production by default) without an id. It gives the state (`running`, `completed`, `failed`), the outcome of a failed one, the progress counts, and, once it has ended, the manifest. The manifest lists each table's CSV file with its columns and row count and the database's read instant, and each area file with its size and version tag. A download that returns a different version from the manifest's is a file that moved after the listing. Once an export has completed, you download it by calling `request_export` with `download: true` and running the command it returns.",
      "owners": [
        "API-L0-18",
        "API-L0-23",
        "MAPI-21"
      ],
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "openWorldHint": false,
        "idempotentHint": true
      }
    },
    {
      "name": "generate_image",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "summary": "Generate design assets for your own app, such as a logo, icon, hero image, illustration, UI mockup, or diagram. With no `application`, your account keeps it for 7 days. `link` opens it in a browser until `expires_at`, at most one hour. `renew_image_link` gives a new link and ends the old one. Pass `application` to keep an asset in an app's storage, with no deployed code needed. Its stored-data limit can refuse the call before anything is saved or counted.\n\nThe first images of each UTC month are free. `free_images` gives how many. Later delivered images draw the account's balance by resolution. `read_account` shows use under your sign-in or an authorized computer's token.\n\nA saved picture normally includes two download commands. If a link or grant cannot be made, it stays saved and counted. `detail` gives the remedy.\n\nOn MCP, `inline: true` also returns a picture at most 256 KiB as image content. Past 45 seconds, the call fails and gives the image back. A failed give-back stays counted and uncharged, as the detail says. A repeat that delivers uses another image.\n\n`resolution` is `1K`, the default, or `2K`. The platform uses one model. The prompt reaches its provider, and the platform stores nothing about it. The application form keeps the picture in `images-<application id>` until deleted. It uses `environment`, or the application's deploy target, and its download commands send a read-only grant valid for five minutes. The account form's commands fetch the link without a header.\n\nA provider block returns `blocked: true` with the reason, saves no file, and gives the image back. A saved picture or provider block includes `used`, `free_images`, and `resets_at`. A provider refusal before any picture normally gives the image back. `image_generation_unavailable` means the platform cannot make images right now, including where no key is stored. It also covers an unreadable key, no current model price, or the platform's monthly ceiling. Past the month's free images while the account is paused, `account_paused` refuses the call before the provider is called, counting and charging nothing. The account store keeps PNG, JPEG and WebP. Any other provider type fails `image_generation_failed`, with nothing saved and the image given back.",
      "owners": [
        "ACB-L0-93",
        "PRC-L0-18",
        "ACB-L0-26",
        "OST-L0-01",
        "OST-L0-08",
        "API-L0-17",
        "SEC-L0-07",
        "PLD-L0-96"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": false,
        "openWorldHint": true
      }
    },
    {
      "name": "renew_image_link",
      "resource": "account",
      "tier": "reversible",
      "surface": "account",
      "addresses": [
        "tzcloud",
        "tztools"
      ],
      "summary": "Renew your link to a picture `generate_image` saved without `application`. Pass its `name`. Each call ends the previous link and gives one valid for at most one hour, never past `kept_until`. Anyone with `link` can open the picture in a browser without signing in. The answer also gives two download commands. On MCP, `inline: true` also returns the picture as image content if it is at most 256 KiB. A larger or unreadable picture still has its link. The picture is kept for 7 days. After `kept_until`, the call refuses `image_expired` while the picture's record remains. A name your account holds no picture of refuses `image_not_found`. This call generates no picture and uses no image from your cap.",
      "owners": [
        "ACB-L0-93",
        "API-L0-17",
        "SEC-L0-07"
      ],
      "annotations": {
        "readOnlyHint": false,
        "destructiveHint": true,
        "openWorldHint": false
      }
    }
  ]
}

```
