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

# Source: management\_api\_contract\.md

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

Source path: management\_api\_contract\.md.

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

## Contract text

### The Management API — Resource Contract

### Purpose

This file is the resource contract for the one management API the management API PRD describes: the resources the plane exposes, the actions over them, how the contract is versioned, and how a credential binds to it\. It is the layer the MCP surface derives from: the tools of `mcp_surface.md` are these actions, surfaced \(MCP\-03\)\. A test in the platform's suite holds the two enumerations to each other — an automated check of API\-L0\-01's requirement that each client expose only capabilities of the management API\.

The launch enumeration has one home: `schemas/management_api.json` beside this document — the resources, and action by action the resource it operates on, its authority tier, and which clients may call it\. This document states the rules the enumeration obeys and repeats none of its rows\.

What this document does not cover: the per\-action payload schemas, which land with each action's implementation \(raised below; the route rule, methods, and error shape are MAPI\-10's\); the served three\-form derivation of API\-L0\-09, `served_context.md`'s; and the pending action's own mechanics, which stay API\-L0\-07's\.

Requirements are numbered MAPI\-nn\.

### The contract

MAPI\-01 \(decided\): The management API is one versioned HTTP contract of resources and actions: every capability is a read of a resource or an action upon one, and every resource and action is enumerated in `schemas/management_api.json`\. A capability enters the plane by entering that enumeration\. There is no unenumerated endpoint for a surface to lean on, which is what keeps every surface a client \(API\-L0\-01\)\.

MAPI\-02 \(decided\): The contract carries its version — `1` at launch — stated in every exchange\. Within a version, evolution is additive: new resources, new actions, new optional fields\. Removing or renaming anything, or changing an action's tier, is a new contract version, never a quiet edit — the callers are AI coding tools acting on this contract's served descriptions, and a description that drifts under a caller is a capability that lies\.

Removing a request member within a version is a change a caller observes, since a call that names a member its action does not declare is refused \(MAPI\-22\)\. So a removal is admitted only as a use of the shape clause below while that clause runs, and is a new contract version after\. One removal was made before that rule stood, when a caller that sent the member observed no difference in the call's answer\. It took the optional `request_id` member, which no implementation ever read, from twelve reversible request schemas in `schemas/action_payloads.json`, named in MAPI\-04\. The HTTP route holds a call's member names to the request schema and validates no member's value\.

Until the platform holds one hundred builder accounts that each hold a live application, a member's shape may change within version 1 in the interest of a cleaner contract\. A synthetic account \(ACB\-L0\-79\) is not a builder account for this count\. A change that removes or renames nothing needs no separate approval under the owner's standing ruling\. A rename or removal needs the owner's approval by name\.

While the clause runs, an action renamed under that approval answers `unknown_action` at its old name on the actions route, naming the successor\. Its tool surface follows MCP\-08's revision move\. An action removed under that approval answers `unknown_action` at its old name; its tool surface follows the same revision move\.

The session records the account count at the change and records the change in this document — by the statement that owns the member, or by this statement where none does\. The served schema's version member moves at the change's landing, so that a caller regenerates its view\. The platform's own callers change with the member, and no served description drifts under a caller it was made for\.

The records carry ordinals from the first to the eighty\-ninth, each the name a citation gives its use, and the numbered series closes there\. A later use's record carries no ordinal and names the member it changes\. In this statement it opens `This clause's use on`, and in the statement that owns the member it opens `This statement records a use of MAPI-02's shape clause on`\. So two branches that each record a use record two, and every ordinal a citation names keeps its use\.

Every content change to a served schema file moves that file's `version` member\. The served schema files are the files the index `schemas/served_context.json` names, itself among them, that carry a top\-level `version` member, a date and a counter\. A description's wording and an enumeration widened to values the service already answers are included, because the served descriptions are the contract an AI caller acts on, and one version string naming two contents is the drift this statement forbids\. An entry of the words override file \(PLD\-L0\-114\) is no content change to a served schema file and moves no version, so a listing's words can change under an unmoved version while the entry stands\.

No session writes the member: on a session branch the registrar refuses a revision that changes it\. The served `integrate` writes the next value at the landing into each such file whose bytes differ from the trunk's\. The next value is the trunk's value with its counter plus one, or the landing day's UTC date with the counter 1 where that day is later than the trunk value's date \(kit:REG\-15; kit:REG\-88\)\. So the rule is mechanical, no session judges which changes move it, and two branches that revise one file land as consecutive values\. `schemas/library_catalog.json`, the catalog's shape and not its rows, carries no `version` member, lands byte for byte, and rides CTX\-01's suite\.

Because the value is written at the landing, a control\-plane release never carries an unlanded change to a file that declares the member\. The control plane's release script \(PLD\-L0\-65\) fetches the remote trunk and refuses a release whose HEAD holds such a file in bytes the remote trunk's first\-parent history does not hold at that path, or whose working copy of such a file differs from HEAD's\. The branch is integrated first, and the release then runs from the landed trunk commit\.

The rule holds on every estate the register names \(PLD\-L0\-85\)\. A development\-role estate is released to from the landed trunk as production is, so a promote of its build to production \(PLD\-L0\-65\) carries forms the trunk holds\.

The fetch must succeed, except in a rollback\. There, where the fetch fails, the script reads the remote\-tracking ref the clone holds, admits the rollback only where every such file stands at that ref's tip or in its first\-parent history, and says that the fetch failed and the held ref vouched\. The exception stands because a ref the run could not refresh holds a past value of the remote trunk, which can only under\-report what landed, and a rollback is the act an incident needs\.

A widened response enumeration is a member's shape change under the clause above, recorded as one of its uses\. This clause's first use: the `environments` member of `list_applications`'s response in `schemas/action_payloads.json`, an array of environment names becoming an array of objects, each an environment's name, state, serving version, and hostname, when the platform held one builder account\.

This clause's second use: the `state` member of each environment in `list_applications`'s response in `schemas/action_payloads.json`, an enumeration of three values — `deploying`, `deployed`, `never_deployed` — becoming one of five with `halted` and `deleting` added\. The platform then held one builder account\. It is recorded here because no statement of this contract owns the member\.

This clause's third use: the `source` member of `read_logs`'s request in `schemas/action_payloads.json`, whose value `all` \(three console logs merged by time\) and whose omission \(the `app` and `platform` sources\) became the application's stream whole, every source the logging store holds\. The platform then held one builder account\. It is recorded here because no statement of this contract owns the member\.

This clause's fourth use: `submit_manifest`'s response members `credential` and `platform_credential` in `schemas/action_payloads.json`, answered on the wire surface alone and withheld on the MCP surface, the member `credentials` added to state which form the answer took\. The same use made `rotate_secret`'s request member `value` optional for the two platform\-minted re\-mints\. The platform then held two builder accounts\. It is recorded here because SEC\-L0\-07 and DBS\-L0\-02 own the members and neither is a statement of this document\.

This clause's fifth use: the cutover of the platform's wire vocabulary to the product's public names \(CQ\-44\)\. That vocabulary is the headers the serving router sets and the control plane reads, the settings the deploy injects, the OAuth scope, the credential prefixes and the browser cookies, and the product profile value\. It is a change that stops every application built before the release until its owner rebuilds it and refuses every credential issued before the release, admitted by API\-L0\-16 as amended\. The platform then held two builder accounts that each held a live application \(three live applications in all, two on the operator's account and one on the second account\)\. It is recorded here because the change reaches every member and no one statement of this contract owns it\.

This clause's ninth use, the wire error shape's members, is recorded by MAPI\-10, the statement that owns the shape, as is every later use that changes a refusal's members, the fourteenth and the thirty\-second among them\.

This clause's nineteenth use: the `issue_tracking` member of `submit_manifest`'s response in `schemas/action_payloads.json`, each environment's entry losing its `origin` and `settings` members and keeping the space's identifier and its outcome\. No setting of the issue service is injected any more: an application reaches its space through the egress gateway's `issue-tracking` upstream, which presents the space's token \(EGW\-L0\-06\)\. The platform then held one builder account that held six live applications, the synthetic estate's one account aside \(read from the production control database's rows\)\. It is recorded here because ITS\-L0\-01 owns the member and is not a statement of this document\.

This clause's twenty\-second use, the narrowed range of `wait_seconds` on `read_status` and `read_schedules`, is recorded by MAPI\-04, the statement that owns the member\.

This clause's thirty\-third use: `deploy`'s request and its answer to the preparing call in `schemas/action_payloads.json`\. The answer's `upload` loses `address` and `commands` and gains `command`, the one line that runs the turnzero\-cloud command \(PLD\-L0\-94\)\. The request gains `zip_sha256`, which every preparing call must name, a call without it, or with a value of another form, refused `zip_sha256_required` on every surface\. The request's `local_path` gains a pattern refusing the characters a shell would change inside the line's double quotes, its absence naming the folder the line runs in, not `app.zip`\. Over MCP a `local_path` outside the pattern draws the argument's validation error before the handler\. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, `schemas/mcp_surface.json`, and `schemas/wire_errors.json` move with it\. The descriptions moved when the platform held one builder account, which held six live applications\. It is recorded here because PLD\-L0\-86 owns the members and is not a statement of this document\.

This clause's thirty\-fourth use, the `value` member of `store_secret`'s and `rotate_secret`'s requests marked `x-wire-only` and leaving both tool shapes, is recorded by MAPI\-08, the statement that owns the argument derivation\.

This clause's thirty\-ninth use: the `application_spaces` member of `export_account`'s `feedback` in `schemas/action_payloads.json`, renamed `spaces`, each entry gaining `kind` and its `application` and `environment` admitting null\. The member carries the account's own filings from each space the account owns, binds, or holds in custody for a standing pair\. The description in `schemas/action_payloads.json` moves with it\. The platform then held one builder account and six live applications, a synthetic account aside, read the same way at the change\. It is recorded here because ACB\-L0\-47 owns the member and is not a statement of this document\.

This clause's forty\-sixth use, the preparing form of `store_secret` and `rotate_secret` and the members their requests and responses gained for it, is recorded by MAPI\-08, the statement that states that form\.

This clause's fiftieth use, the refusal of a call that names a member its action does not declare, is recorded by MAPI\-22, the statement that owns the rule\.

This clause's fifty\-fourth use: `submit_feedback`'s `issue` member and three refusals on the platform's own space, for a credential that does not read the queue\. The member is null where MAPI\-18 withholds the issue, where it was an object in every answer\. The recovered mark answers the member's `id`, `status`, and `disposition` alone, where it answered the issue as the 0\.2\.0 wire gives it\. A confirmation that names a restricted issue, and a recovered mark MAPI\-18 does not relay, are refused where each was relayed\. The description in `schemas/action_payloads.json` moves with it\. The platform then held one builder account and no open invitation, read at the change\.

This clause's fifty\-eighth use: the admission window on every management action\. A call to `list_library` or `read_library_entry` from a source past three thousand such calls in the minute is refused 429 `rate_capped` where it was answered\. So is a call to `list_context` or `read_context`, or one that names an action with no handler or no action, from a source past six hundred requests in the minute\. The admission window's 429 `rate_capped` at the control plane carries a `Retry-After` header, the seconds to the next minute, where it carried none\. The summary of `rate_capped` in `schemas/wire_errors.json` moves with it\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-67, which states the window, is not a statement of this document\.

This clause's sixtieth use: the admission window of a request that presents a credential on the storage, egress, logging, and push wires\. A request there whose presented value resolves to no credential counts in a window its source has for such requests, and past six hundred of them in the minute is refused 429 `rate_capped` where it was answered 401 `authentication_required`\. Every token of one end\-user session counts in that session's one window, where each counted in its own\. A request there in another letter case, or with a route's one trailing slash, counts as the path as written does, where it counted by its source\. The summary of `rate_capped` in `schemas/wire_errors.json` moves with it\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-67, which states the window, is not a statement of this document\.

This clause's sixty\-first use: `submit_feedback`'s answer to a confirmation that names a restricted issue, for a credential that reads the queue on the platform's own space and for any credential on a space the request names\. The confirmation is refused 404 `not_found` as one naming no issue is, where it was relayed and linked, for a report the plane filed `field`, `beta`, `person`, or `test`, since the service confirms none of those onto a restricted issue \(MAPI\-18\)\. The platform then held one builder account, one synthetic account, and no open invitation, read at the change\.

This clause's sixty\-second use: `submit_feedback`'s `issue` and `outcome` members where a filing's evidence matches a report on a restricted issue, on the platform's own space and on a space the request names, for a report the plane filed `field`, `beta`, `person`, or `test`\. The `issue` member carries the unrestricted issue the filing joined or opened, and `outcome` reads `filed` where the filing opens an issue of its own, where it read `linked`\. On the platform's own space the `issue` member was null for a credential that does not read the queue; for one that reads it, and on a named space, it was that restricted issue through the projection \(MAPI\-18\)\. The platform then held one builder account, one synthetic account, and no open invitation, read at the change\.

This clause's sixty\-third use: `submit_feedback`'s recovered mark, for a credential that reads the queue on the platform's own space and for any credential on a space the request names\. The mark is refused 404 `not_found` where the caller's filing under the key did not open the issue, or another reporter's report stands on it, where it was relayed and settled the filing \(MAPI\-18; the package's XIT\-01\)\. The platform then held one builder account, one synthetic account, and no open invitation, read at the change\.

This clause's sixty\-fourth use: what `relay_issue_act` answers a token below the `owner` level of its `issues` grant\. A relayed `follow`, `update`, `comment`, `relate`, or `give_back` naming an issue ITS\-L0\-05 withholds is refused 404 `issue_refused`, as one naming no issue is, where it answered 200\. A relayed `submit`'s or `check`'s `issue` member is null for such an issue, and a relayed `next` answers each member null, where each was as the service gave it\. A relayed `arising_from` relation whose target has an issue identifier's form is refused 400 `invalid_request`, where it answered 200\. A relayed `submit`'s report carries the origin `field`, where it carried the origin the body named, so one of the kind `question` or `task` is refused 400 `issue_refused`\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because ITS\-L0\-05 is not a statement of this document\.

This clause's sixty\-fifth use: `submit_manifest`'s `settings` rows on an application with one environment\. The answer carries one row per setting, production's, where it also carried a row naming development\. No deploy or promote of such an application reads the development scope, and an AI coding tool read that row's `stored: false` as a value to store\. An application with both environments is answered both rows, as before\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because MAN\-14 is not a statement of this document\.

This clause's sixty\-seventh use: `deploy`'s answered `state` in `schemas/action_payloads.json`, with one request member and one refusal\. The answered `state` gains the values `awaiting_command` and `withdrawn`\. The request gains the member `withdraw`, which the HTTP action route alone carries, and the response gains `command`, `command_windows`, `expires_at`, and `previous_code`\. The refusal catalogue in `schemas/wire_errors.json` gains `deploy_code_refused`\. The plane admits the member and answers the values, the members, and the refusal only where it serves the line form of `deploy`\. Where it does not, a call naming `withdraw` on the HTTP action route is refused 400 `invalid_request`\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-86, which states the line form and the deploy code, is not a statement of this document\.

This clause's sixty\-eighth use: `deploy`'s request and its answers in `schemas/action_payloads.json`\. `zip_sha256` is marked wire\-only beside `withdraw`: the MCP tool declares neither, and a tool call naming either is refused 409 `local_route_required` where it prepared an upload\. A call naming none of `zip_sha256`, `artifact`, and `upload` answers the line form, 200 `awaiting_command`, where it drew 400 `zip_sha256_required`, and that row leaves `schemas/wire_errors.json`\. The preparing call's answer gains `upload.grant`, and `upload.command` and `upload.command_windows` carry that value where each carried a line\. At the preparing form a grant\-form bearer resolving to no credential is refused `deploy_code_refused` where it drew `authentication_required`, and a start under a session or token of an upload a later deploy call ended is refused `upload_not_found`\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-86 owns the members and is not a statement of this document\.

This clause's sixty\-ninth use: `deploy`'s answer to a deploy, by the artifact or the upload form, to an environment that holds no serving version, whose zip names its manifest's health path in no source file\. It was answered 202 and started, and is now refused 400 `health_path_unserved` before any write, a row the refusal catalogue in `schemas/wire_errors.json` gains\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-63, which states the check, is not a statement of this document\.

This clause's seventieth use: `read_logs`' answer in `schemas/action_payloads.json`\. A `container` read that was refused `never_deployed` where the environment names no compute is answered where a failed first deploy's or first promote's health check kept a record, and the answer gains the member `failed_check`\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-59, which owns the behaviour, is not a statement of this document\.

This clause's seventy\-first use: what `relay_issue_act` answers a `contribute`\-level `issues` grant, which the sixty\-fourth use recorded for every level below `owner`\. A relayed `list` answers a restricted issue it left out, and a relayed `read` answers one it refused 404 `issue_refused`\. A relayed `update`, `comment`, `relate`, or `give_back` naming one now reaches the service, once refused 404 `issue_refused`\. A relayed `submit`, `check`, or `next` answers such an issue whole, once null, with no lease given back\. A relayed `update` whose `fields` name `restricted` with any value but `true` is refused 403 `issues_level_refused`, where it answered 200\. A relayed `follow` naming one is still refused 404 `issue_refused` by the service, its report carrying the origin `field`\. The platform held 1 builder account and 0 open invitations, read at the change; ITS\-L0\-05 is not a statement of this document\.

This clause's seventy\-second use: `deploy`'s answer at its wire preparing form to a deploy code whose minting credential no longer stands, a token revoked or expired or a session ended since the mint\. It was admitted where the code's own end was not written, and is now refused 403 `deploy_code_refused`, alike to an unknown code's answer\. A code a session minted on the earlier revision is refused so once\. The same use has `reinstate_account` refused with the store's failure, the account still suspended, where ending its codes fails, and a session's code answer an `expires_at` no later than its session's expiry\. The platform then held one builder account and no open invitation, read at the change\. It is recorded here because PLD\-L0\-86 is not a statement of this document\.

This clause's seventy\-third use: the lookup limit on the storage, egress, logging, and push wires\. A request whose presented value the gateway cache does not hold, and whose lookup cannot start within the wait bound, is refused 503 `credential_lookup_busy` with `Retry-After` of one second, where it was looked up\. Through the edge, such a request from a source at its bound for unresolved values is refused 429 `rate_capped` before its lookup, where a value that then resolved was admitted\. The `credential_lookup_busy` row and the summary of `rate_capped` in `schemas/wire_errors.json` move with it\. The platform then held one builder account, a synthetic test account beside it, and no open invitation, read at the change\. It is recorded here because PLD\-L0\-67, which states the limit, is not a statement of this document\.

This clause's seventy\-fifth use: the action `rotate_realm_keys`, renamed `revoke_realm_keys` with its MCP tool, because the act revokes the realm's session signing keys \(ACS\-L0\-08\)\. The owner approved the rename\. Over the actions route a call naming the old name answers 404 `unknown_action`, its detail naming `revoke_realm_keys`, and the tool surface moves with MCP\-08's revision 2\. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, `schemas/mcp_surface.json`, and `schemas/wire_errors.json` move with it\. CQ\-97's three action renames within version 1 are the precedent\. The platform then held one builder account and no standing synthetic account, read at the change\. It is recorded here because ACS\-L0\-08, which owns the action, is not a statement of this document\.

This clause's seventy\-sixth use: the value `redeploy` of the `kind` member of each row in `list_versions`' response, of the `deploy` member in `read_status`'s response, and of `failed_check` in `read_logs`' response in `schemas/action_payloads.json`, renamed `restart`\. The versions table's stored value, the stores that read it back, and the mark\-redeploy pass keep the name `redeploy`, and the answers write `restart` for it, as the seventeenth use kept `heartbeat_at`\. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, and `schemas/mcp_surface.json` move with it\. The platform then held one builder account and no standing synthetic account, read at the change\. It is recorded here because PLD\-L0\-63 owns the member and is not a statement of this document\.

This clause's seventy\-seventh use: the realm member `routes`, renamed `sign_in_methods` in `configure_realm`'s request and answer, in `read_realm`'s and `export_account`'s answers, and in the manifest's `realm` member\. The control database's column `realms.routes` keeps its name\. `configure_realm`'s request carries MAPI\-22's `x-renamed` for `routes`, so a call naming it is refused `invalid_request` naming `sign_in_methods`\. A recorded manifest naming `realm.routes` is read under `sign_in_methods`\. A submitted one is refused `manifest_invalid` at `/realm/routes`, its detail naming `sign_in_methods` and the one\-line edit that renames the member\. The descriptions in the payload contract, the tool catalog, the API schema, and the manifest schema move with it\. The platform then held one builder account and no standing synthetic account, read at the change\. It is recorded here because ACS\-L0\-07 owns the member and is not a statement of this document\.

This clause's seventy\-ninth use: the member `after` of `submit_manifest`'s `provisioning` in `schemas/action_payloads.json`\. Where the request names `local_run` and development is deployed or a deploy of it is in flight, it says the line revokes the credentials that copy holds\. It also says that the line's last re\-mint restarts that copy, and that where a deploy of it is still in flight the re\-mint's answer names `restart_application` instead\. The description in `schemas/action_payloads.json` moves with it\. The platform then held two builder accounts and no standing synthetic account, read at the change\. It is recorded here because SEC\-L0\-07 owns the member and is not a statement of this document\.

This clause's eightieth use: `list_secrets`' request in `schemas/action_payloads.json`, which took no member and gains two optional ones\. `application` narrows the answer to that application's scopes, refused `no_such_application` for an id the account does not own, and `environment`, riding it, to one scope\. The descriptions in `schemas/action_payloads.json` and `schemas/mcp_surface.json` move with it\. The platform then held two builder accounts and one standing synthetic account, read at the change\. It is recorded here because EGW\-L0\-09 owns the action and is not a statement of this document\.

This clause's eighty\-first use: `read_counters`' response in `schemas/action_payloads.json` gains an optional member, `detail`, present on an empty answer alone\. It says the counters are the application's own count calls, which a request never writes, that the platform's usage is read with `read_usage`, and that a count arrives within a few seconds\. The platform then held two builder accounts and one standing synthetic account, read at the change\. It is recorded here because system:LGS\-L0\-15 owns the action and is not a statement of this document\.

This clause's eighty\-second use: the `realm` object of `submit_manifest`'s response in `schemas/action_payloads.json` gains an optional member, `entra_callback`, present where the manifest's realm member names `entra`\. It is the work\-account route's redirect address, the realm reads' `callbacks.entra`, which the tenant's app registration lists\. The platform then held two builder accounts and one standing synthetic account, read at the change\. It is recorded here because ACS\-L0\-09 owns the route and is not a statement of this document\.

This clause's eighty\-fourth use: `submit_manifest`'s response in `schemas/action_payloads.json` gains a member, `hostnames`, on every recorded submission\. It holds one member per environment the application has, each the hostname `list_applications` names for it, so the receipt says where the application answers before a first deploy\. The platform then held three builder accounts and two standing synthetic accounts, read at the change\. It is recorded here because PLD\-L0\-40 owns the hostnames and is not a statement of this document\.

This clause's eighty\-fifth use: `submit_manifest`'s response in `schemas/action_payloads.json` gains a member, `changed`, on every recorded submission\. It is true where the manifest the submission recorded differs from the one recorded before it, or none was, and false where the submission repeats the recorded manifest, so a resubmission says it changed nothing\. The platform then held three builder accounts and one standing synthetic account, read at the change\.

This clause's eighty\-sixth use: an upstream declaration's member `settings`, renamed `sdk_settings` in `declare_upstream`'s request and answer, in `undeclare_upstream`'s and `list_upstreams`' answers, and in an entry of the manifest's `upstreams` member\. The control database's column `egress_upstreams.settings` keeps its name\. The former name was kept as a deprecated alias on both carriers, as EGW\-L0\-01 states, and a recorded manifest naming it is read under `sdk_settings`\. The descriptions in the payload contract, the tool catalog, and the API schema move with it, and so do those in the manifest schema, the refusal catalog, and the skills catalog\. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because EGW\-L0\-01 owns the member and is not a statement of this document\.

This clause's eighty\-seventh use: the `halted` member of `halt_environment`'s, `resume_environment`'s, and `read_schedules`' responses in `schemas/action_payloads.json`, and of `read_status`'s environments, reads `false` where the environment runs, where it read `null`\. While the environment is halted it still holds the halt's instant and author, so a reader is told an environment is not halted without inferring it from a null\. The platform then held three builder accounts and one standing synthetic account, read at the change\.

This clause's eighty\-eighth use: `read_status`'s request in `schemas/action_payloads.json` gains an optional member, `brief`, true or false\. Where it is true, the answer keeps the members that say whether each environment is up and what its last deploy did, and leaves out the rest\. Absent or false, the answer is the whole one, unchanged, and a value that is not a boolean is refused `invalid_request`\. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because PLD\-L0\-105 owns the member and is not a statement of this document\.

This clause's eighty\-ninth use: each entry of the `undeclared` list in `read_status`'s `egress` member, described in `schemas/action_payloads.json`, gains a member, `upstreams`, where the entry's host is the base URL host of an upstream declared for the application\. It names those upstreams, sorted, and the entry's remedy then names the gateway route first\. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because EGW\-L0\-17 owns the member and is not a statement of this document\.

This clause's use on `submit_manifest`'s response in `schemas/action_payloads.json`: it gains a member, `storage_areas`, where the manifest's `object_storage` entry lists areas\. It carries each listed area as `list_storage_areas` answers it, with its outcome, `created` or `unchanged`, and its whole file address\. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because OST\-L0\-01 owns the member and is not a statement of this document\.

This clause's use on `submit_manifest`'s response in `schemas/action_payloads.json`: it gains a member, `egress_notice`, where an entry of the manifest's `egress` member admits the host of one of the application's declared upstreams\. It names each such host with its upstreams and says a direct call to it carries no key the gateway applies\. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because EGW\-L0\-02 owns the member and is not a statement of this document\.

This clause's use on `issue_invitation`'s request `products` items in `schemas/action_payloads.json`: the enum gains `tzteam`, the tzTeam profile's name from the product rename, beside `blueprint`, its earlier spelling, which the plane reads as `tzteam` through the rename's window \(ACB\-L0\-76; ACB\-L0\-77\)\. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because ACB\-L0\-77 owns the member and is not a statement of this document\.

This clause's use on `submit_manifest`'s response in `schemas/action_payloads.json`: each row of its `schedules` gains a member, `cron_preview`\. It holds up to three instants the row's expression yields after the submission, as `read_schedules` answers them, and null on a row the submission ended\. The descriptions in `schemas/action_payloads.json` and `schemas/skills.json` move with it\. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change\. It is recorded here because SCH\-L0\-07 owns the member and is not a statement of this document\.

This clause's use on nine actions, each merged with its MCP tool into one of five successors that take a mode member \(`declare_storage_area`, `declare_upstream`, `set_end_user_standing`, `invitation`, and `test_end_users`\), the tool surface moving with MCP\-08's revision 5\. `undeclare_storage_area` and `undeclare_upstream` are now `declare_storage_area` and `declare_upstream` with `remove` true\. `revoke_end_user` and `reinstate_end_user` are now `set_end_user_standing` with `standing` `suspended` or `active`\. `issue_invitation` and `revoke_invitation` are now `invitation` with `act` `issue` or `revoke`\. `create_test_end_users` and `delete_test_end_users` are now `test_end_users` with `act` `create` or `delete`\. `withdraw_test_end_users`, merged into the act `withdraw`, retired with that act at MCP\-08's revision 8, and it answers `unknown_action` naming no successor \(ACS\-L0\-21\)\. The owner approved the merges\.

This clause's use for the owner's approved app sign\-in renames under the addresses plan's decision 11 \(family:Q\-313\): `configure_realm` becomes `configure_app_sign_in`, `check_realm` becomes `check_app_sign_in`, `read_realm` becomes `read_app_sign_in`, and `revoke_realm_keys` becomes `revoke_app_sign_in_keys`\. Each rename changes the action, its REST address, its tool and its first\-party callers together, a hard cutover within version 1 without an alias\. Each old action name answers 404 `unknown_action` naming its successor, on the actions route and as a tool's error result\.

This clause's use on `deploy`'s preparing answer in `schemas/action_payloads.json`: its `upload` leaves out `command` and `command_windows`, which carried the upload grant's value beside `grant` since the sixty\-eighth use, and `grant` carries that value alone\. The command floor refuses every command that read either member \(PLD\-L0\-109\)\. The platform then held 6 builder accounts that each held a live application, synthetic accounts excluded, read on production in the release dry run at the change\. It is recorded here because PLD\-L0\-86 and OST\-L0\-08 own the members and are not statements of this document\.

This clause's use on `reassert_compute` removes the operator action within contract version 1 at the owner's approval by name\. Its old name answers `unknown_action` on the actions route, naming no successor, and its tool leaves the operators' MCP address under MCP\-08's revision move\. Every estate uses the usage form, so the walk can only compare equal terms and record unchanged compute\.

MAPI\-03 \(decided\): A credential is a bearer credential presented per request, never carried in a URL, and is one of four kinds: the **session credential**, the **minted token**, the **platform credential**, and **no credential**\. Beside them, the third and eighth paragraphs admit three short\-lived grants, each on the requests its act admits and nothing else\. The session credential is minted by a present person's sign\-in and takes three forms\. The first is the bearer session the OAuth flow issues \(MCP\-02's binding\)\. The second is the browser credential the approval page and the operator's CSV download under `/dashboard` run under \(MAPI\-05; WEB\-L0\-16\), no credential on the wire\. The third is the browser session, the API cookie of the browser leg \(WEB\-L0\-16\), which the cookie address alone admits as a wire credential, under a guard of its own \(MAPI\-10; CQ\-283\), and under which the signed\-in site's pages run their acts \(CQ\-63\)\.

The **minted token** of API\-L0\-05 is created by a session through `mint_token` and bounded at its minting to the account or to one application \(API\-L0\-17; MAPI\-14\)\. The one exception is the support read token, which the support consent route mints under the support cookie \(WEB\-L0\-16; MAPI\-29\)\. The CI credential and the application\-bounded builder credential are this one kind under its two scopes\. The **platform credential** of SEC\-L0\-07 is admitted here by `read_account` alone\. The fourth kind is **no credential**, the kind a marked row runs as for a caller whose account does not act \(MAPI\-11\)\. It is also the kind `search_documentation`'s signed\-out search answers, for a request presenting no bearer credential \(CTX\-10\)\.

A credential the platform issues for a data\-plane act alone is refused by name on every action of this contract, but for the start of an upload that `deploy` admits under that upload's own grant \(OST\-L0\-08; PLD\-L0\-86; CQ\-270\)\. Those are the end\-user credential the accounts service issues, the transfer grant object storage mints, and the egress key the platform mints for one upstream of one compute \(SEC\-L0\-18\), each stated by its own surface\. The secret grant, which the platform mints for one custody act, is admitted on `store_secret` over the wire for the requests its act admits, and on nothing else \(SEC\-L0\-19\)\. Every other action, and a request the grant's act does not admit, refuses it `secret_grant_not_admitted`, but for the rules the sixth paragraph names\. A request it admits is refused `secret_grant_spent` once the grant is spent, and `secret_grant_expired` once it has expired unspent\.

A bearer of a grant's form that resolves to no credential is refused `authentication_required`, with the challenge MCP\-02 states for a presented credential that resolves to nothing\. Such a bearer is a grant never minted, a grant whose record the platform has removed after its expiry or with its application or account, or a value that differs from the one minted\. No record answers, so the refusal names no kind of grant\. Its detail says that the platform serves no grant of that value, and that a grant lasts minutes and serves the one act its mint names\. It names both ways to a fresh grant: a tool call whose answer carried the grant is made again and the fresh command it answers is run, and an application that requested the grant requests another\.

The browser session is read only from a same\-origin JSON post that presents no `Authorization` header and is verified as the dashboard guard verifies its cookie\. It is admitted on a row naming both `bearer` and `browser_session`, or `browser_call` alone; the approval row naming `browser_session` alone stays on its own page \(MAPI\-05\)\. Every other row refuses it `authentication_required` before any store read\. A state\-changing action under it past the freshness window WEB\-L0\-16 states is refused `fresh_authentication_required`\. It runs on the `browser` surface, which is answered no credential value but `mint_upload_grant`'s upload grant \(SEC\-L0\-07; OST\-L0\-08\)\. Every other surface, `/mcp` and the data\-plane surfaces among them, keeps resolving the `Authorization` header alone\. The authority tiers bind per credential \(API\-L0\-06\): what a credential may do is its grant, the destructive class is deny\-until\-granted, and no client kind carries a laxer tier than any other \(API\-L0\-11\)\.

This paragraph names the rules that answer a request presenting a secret grant ahead of the third paragraph's refusal\. The approval action reads no credential on the actions routes and refuses any bearer `browser_session_required` \(MAPI\-05\)\. A page's own action, whose row names `browser_call` alone, refuses any `Authorization` header with that name before reading a credential \(MAPI\-03\)\. An action switched off reads the grant and refuses by its switch's name \(MAPI\-16\)\. Neither admits the grant to anything\.

A secret grant whose act is `provision` is admitted on `store_secret` with `replace: true` over the wire for its application's two platform\-minted names at the development scope, each once \(SEC\-L0\-19\)\. Its bearer is the verifier the turnzero command keeps, read as the next paragraph states\. The request names no value and carries no member beyond `replace: true`, the name, the application, the environment, and `code_verifier`, which a grant bound to a challenge requires \(SEC\-L0\-19\)\. A second re\-mint of a name is refused `secret_grant_spent`\. `submit_manifest` takes the member `local_run`, which asks for that grant's line: `true` alone, on the MCP surface and over the wire under a bearer credential\. Any other value, and the member on a surface that is answered no credential, is refused `invalid_request` with nothing recorded\. Beside it a submission names `code_challenge`, which binds the grant to that verifier, and without it no grant is minted\.

This paragraph adds the token code to the third paragraph's short\-lived grants\. A token code is admitted once, at `mint_token`'s wire exchange form alone\. There a code the plane does not admit, and a bearer of a grant's form that resolves to no credential, are refused as MAPI\-23 states, in place of the fourth paragraph's refusal\. On every other request a token code is answered as the fourth paragraph states, unspent \(MAPI\-23\)\. The seventh paragraph's verifier is read at `store_secret` with `replace: true` over the wire alone, where the guard hands the dispatcher a verifier\-form bearer with no credential prefix that no store answers\. The dispatcher finds the grant by the bearer's S256 challenge and the request's `application`, refuses a suspended owner's grant `account_suspended`, and refuses a claim that finds none `authentication_required` with the fourth paragraph's detail and no challenge\. Elsewhere the verifier is a bearer that resolves to nothing\.

This paragraph states the one exception to the first paragraph's rule that no credential is carried in a URL\. The computer login page \(WEB\-L0\-25\) sends the token code it minted to the turnzero command's listener on the person's own computer, in the query of `http://127.0.0.1:<port>/?code=<code>&state=<state>`\. The code is one\-time, lives minutes, mints nothing without the verifier that computer alone holds, and is sent to the loopback address alone\. The address stands in the browser's history, the one residual, which the record accepts\. Every other credential and grant stays off every URL\.

This paragraph and the two after it add the signed form of a product token to the minted token's kind\. There is one form for every row of the plane's product table \(MCP\-02\), the `tzmesh` row's as it stood and the `tztrack` row's beside it\. The token a product's exchange mints \(MCP\-02; MAPI\-14\) carries its claims and the plane's Ed25519 signature in its value\. The value is the prefix `turnzero_cloud_tok_<product>1.`, a base64url JSON payload, a dot, and the 64\-byte signature over the prefix and the payload\. The prefix carries the product's name and its contract's generation, `turnzero_cloud_tok_tzmesh1.` for `tzmesh` and `turnzero_cloud_tok_tztrack1.` for `tztrack`\. The prefix's `tzmesh1` and `tztrack1` each name that product's contract's first generation; system:XTX\-22 states what changes take a later one and in what order for `tzmesh`, and system:XIT\-24 for `tztrack`, on the same rule\.

The payload names `kid`, the signing key; `iss`, the plane's origin; `aud`, the product's resource; `sub`, the account; `jti`, the token's identity; `level`; `label`; `iat`, the mint; and `exp`, its expiry, each instant in seconds\. The expiry is 180 days after the mint for an exchange's token, and for `mint_token`'s the days the mint named, 180 where it named none \(MAPI\-14\)\. The `tzmesh` service reads `level` and bounds no call by it \(system:XTX\-02\)\. The token the `tzmesh` site's own sign\-in client's code exchanges for carries an `exp` one minute after the mint \(MCP\-02\)\. Each product's service refuses a token whose `exp` has passed, and the person signs in or mints again; no refresh renews it \(API\-L0\-05\)\.

The key is the realm key service's under the product's reserved realm name, `tzmesh` or `tztrack` \(ACS\-L0\-05's keys\), one key set per product, each published as MCP\-02 states\. A retired key stands one token life plus a day, so every token signed under it verifies until its own expiry unless the key is revoked \(MAPI\-09\)\. On this plane the value resolves by its hash, as every minted token's does; each product's service verifies it by signature with no call to the plane\. A `tzmesh` or `tztrack` token `mint_token` mints takes the same signed form at its code's exchange, signed by the accounts service under a single\-use ticket \(MAPI\-23\), since the management process holds no signing key \(SEC\-L0\-07\)\. The tzTrack resource's exchange answers the signed `tztrack` token \(MCP\-02\), and `mint_token`'s is served as MAPI\-23 states\.

This paragraph adds the front's token to the one above, as an exception to its hash rule\. The token the MCP server's front mints for a connection it serves \(MCP\-14\) takes the same signed form\. It has no row here, resolves to nothing here, and is presented at its product's door alone\.

This paragraph adds one optional claim to the payload of a `tzmesh` token's signed form\. A token a builder's application's code exchanges for \(MCP\-02\) carries `application_sign_in`, written only as `true`, the mark of a sign\-in through an application, and every other `tzmesh` token omits it\. A reader takes `false` as it takes absence\. The claim is no application scope of the second paragraph's, and the `tzmesh` service reads it as system:XTX\-22 and system:XTX\-02 state\.

This paragraph adds a second such claim\. A `tzmesh` token of an operator's synthetic test account \(ACB\-L0\-79\) carries `synthetic`, written only as `true`, and every other token omits it, an account seeded with an access link among them \(ACB\-L0\-87\)\. The erasure walk's token omits it too, since no join or send admits that token\. The plane reads the mark from the account's record at the mint, and no request can ask for it\. A reader takes `false` as it takes absence, and the `tzmesh` service reads it as system:XTX\-22 and system:XTX\-05 state\.

This paragraph adds a third such claim\. A `tzmesh` token of an account holding an identity in the operator set \(MAPI\-09\) carries `operator`, written only as `true`, and every other token omits it\. The erasure walk's token omits it too\. The plane reads the account's bound identities against the operator set at the mint, and no request can ask for the mark\. A reader takes `false` as it takes absence, and the `tzmesh` service reads it as system:XTX\-22 states\.

This paragraph adds two optional claims to the payload of a product token's signed form, the MCP front's approval marks \(MCP\-14; MCP\-07\)\. `describe`, written only as `true`, marks the token the front presents to read what a destructive door call would destroy\. `pending_action`, the plane's pending action's identity, marks the token the executor presents for the approved act\. The front mints each for one call, living five minutes, held in no row; no exchange and no `mint_token` writes either\. A door declares on its served row which marks it honours, admits a destructive act under `pending_action` alone, and reads a token carrying neither by its own rule\. Whether a mark moves a product's generation is system:XTX\-22's question for `tzmesh` and system:XIT\-24's for `tztrack`\.

This paragraph states one exception to the fifth paragraph, outside the actions routes\. The six posts of the Questions page under `/api/v1/support/` are the chat id, the consent, its end, the chat's message, the turn read, and the answer's rating \(MAPI\-32\)\. They read the support cookie \(WEB\-L0\-16\), path\-scoped to `/api/v1/support/`, on a same\-origin JSON post that presents no `Authorization` header, verified as the site gate verifies the site cookie, with no freshness window \(MAPI\-29\)\. The site cookie alone signs no chat and admits neither the consent nor its end \(CQ\-283\)\. The message, the turn read, and the rating reach less than the other three\. They resolve the cookie's account only to tell the support application which account a signed\-in chat belongs to, and they mint nothing\. A request with no admitted cookie runs as a signed\-out chat's rather than being refused\.

This paragraph states the one credential value the fifth paragraph's `browser` surface is answered\. A cookie call of `mint_upload_grant` is answered its upload grant \(OST\-L0\-08\), whose copy reaches one write of one named file within the grant's configured lifetime, five minutes by default \(OST\-L0\-08\), and no account act\. The application page uses it at once as the bearer of that one `PUT`, sent in the `Authorization` header and in no URL, and shows it nowhere \(WEB\-L0\-17\)\. Every other credential value stays off the `browser` surface \(CQ\-283\)\.

The tzMesh site's token route is a further exception to the fifth paragraph's header\-only rule \(ACS\-L0\-18\)\. It reads its own path\-scoped cookie and answers a signed `tzmesh` token that lives 300 seconds, with no token\-store row\. The page holds it in memory alone\. It carries `person: true`; `site_session`, an opaque HMAC reference to the browser session; and `fresh: true` where that session signed in within eight hours of the mint\. A false or empty member is absent\. The reference is neither the session row's identifier nor its secret\. The service reads these claims under system:XTX\-22\.

A row naming `browser_call` alone is a page's own act\. Only an API cookie call at the cookie address reaches its handler \(MAPI\-10\)\. It refuses an `Authorization` header 403 `browser_session_required`, even beside a cookie, and reads no bearer\. Without an admitted cookie call it refuses 401 `authentication_required`, with no bearer challenge\. Its admission window is counted once before these refusals \(PLD\-L0\-67\)\.

The credential of an admitted API cookie call carries the generation the verified cookie named and the one admission read held to the session row \(ACS\-L0\-18; ACS\-L0\-25\)\. A suspended account is refused `account_suspended`; WEB\-L0\-16's freshness rule governs a state\-changing action\. The approval page's credential and the executor's carry no cookie generation\.

MAPI\-04 \(decided\): Every action carries its tier in the enumeration — observe, reversible, destructive — and the tier governs the call's shape\. An observe action changes nothing and may be repeated freely\. A reversible action completes in the call that made it or, where its statement says so — `run_schedule`, `deploy`, `promote`, `roll_back`, `restart_application`, and two staff purges —, records the act and answers at once, its outcome read through the observe act that statement names\. Of these, `run_schedule` and the four acts MAPI\-04's paragraph Held acts names answer at once unless the request's `wait_seconds` holds the answer, as that paragraph states\. A retried reversible call is a second call of the action, what a repeat does being each action's own statement's to say\.

A destructive action accepts a client\-supplied request identity, the optional `request_id` member of its request, so a retried request lands on the same pending action once rather than a second one, because the callers are AI coding tools, and retry\-on\-timeout is how they behave\. MAPI\-05 states the match\.

No reversible request schema in `schemas/action_payloads.json` carries a request identity the plane ignores\. The twelve that did, under the names they then had — `mint_token`, `revoke_token`, `configure_app_sign_in`, `revoke_end_user`, `reinstate_end_user`, `issue_invitation`, `revoke_invitation`, `set_plan`, and four of staff's — lost the member as MAPI\-02's second paragraph records, and a call naming it is refused as MAPI\-22 states\.

`run_schedule`'s required `request_id`, which its own code reads, is not within that removal, what its repeat answers being that action's own statement's to say\. The optional `request_id` of the staff seed and purge of synthetic accounts is a member of the same kind, read by their code, each repeat answering as MAPI\-16 states\.

**Held reads\.** This paragraph qualifies the first paragraph's clause that an act answered at once has its outcome read through an observe act\. `read_status`, `read_schedules`, and `read_usage` take optional `wait_seconds`, an integer from 1 to 45\. The payload schema states the range; the MCP argument layer and wire handler hold it \(MAPI\-02\)\. Status waits for the application's version\-history rows still `deploying` \(PLD\-L0\-63\) and uploads in progress on its deploy target \(PLD\-L0\-86\); SCH\-L0\-06 names the schedule wait\. Those two poll every two seconds until nothing is in flight or MAPI\-04's paragraph Wait deadline's bound, then answer `settled` from their final read and `waited_ms`\. Usage holds until that bound, composes its answer from reads after the hold, and adds `waited_ms` without `settled`\. It has no in\-flight condition that ends the hold early\.

**Read bounds\.** This paragraph bounds the held reads above\. Status and schedule compose each answer from their last store read; every early end answers `settled` from that read\. Either answers at once where nothing is in flight\. A process holds at most one read per application, one usage read per account, and fifty in all; a read beyond either applicable bound answers at once\. The deploy command's progress read holds one place per upload, never an application's, within the fifty and its route's 25 seconds \(PLD\-L0\-86\)\. A held read answers at once when its process begins shutting down, before the listener closes, and ends when the caller's connection closes\. An answer of an act of MAPI\-04's paragraph Held acts that did not settle names the wait in its `detail`; `run_schedule` without one names both waits by their actions\.

**Held acts\.** This paragraph extends MAPI\-04's paragraph Held reads' held read to the acts that start a version\-history row, `deploy` in each of its starting forms, `deploy_files` \(API\-L0\-25\), `promote`, `roll_back`, and `restart_application` \(PLD\-L0\-63; PLD\-L0\-84; PLD\-L0\-86\), and to `run_schedule`\. Each takes the same `wait_seconds` and holds its answer until the row it started ends, answering as PLD\-L0\-63 states, or for `run_schedule` until its run ends \(SCH\-L0\-06\)\. Each hold is a held read, polling as MAPI\-04's paragraph Held reads states and bounded as MAPI\-04's paragraph Read bounds states\. So an act's hold takes its application's one held place, and a concurrent held read of that application on the same process answers at once\. An act that finds the place taken answers at once, its `settled` from its own row or run\. `deploy_command` and `deploy`'s preparing call start no row: each holds nothing and carries the member into its `next`, 45 where absent\.

**Wait deadline\.** This paragraph bounds every wait this statement states by the call's time\. A held read or act stops polling once `wait_seconds` have passed since its credential was admitted, so the time an act spends before its hold, a slow artifact read among them, is spent from its wait\. A `container` read's wait stops at the earlier of its `wait_seconds` and forty seconds, so a value above 40 is held 40\. The hold adds nothing past that point but the final read's time, so an answer whose work before the hold took less than its wait stays under fifty seconds\. On the wire, a value outside 1 to 45 is refused `invalid_request` by the handler, its detail naming 45 as the most the member admits, for the four reads, the held acts, and `deploy_command` alike\. Over MCP the argument layer refuses it first, its text naming the same bound\.

This paragraph qualifies the paragraph above's hold for a deploy or a promote whose row ended `deployed`\. Its answer also spends the server\-error count's read, which its bound holds to three seconds \(PLD\-L0\-63\), so it too stays under fifty seconds where its work before the hold took less than its wait\.

**Log waits\.** This paragraph extends MAPI\-04's paragraph Held reads' held read to the log read `read_logs` on a store source\. It takes the same `wait_seconds` and holds its answer while the read with the call's own filters finds no entry, answering from a fresh read with `waited_ms` and no `settled`\. Its hold is a held read of this statement, polling, bounded, and placed as MAPI\-04's paragraphs Held reads, Read bounds and Wait deadline state, and an empty answer whose wait found the place taken says so in its `detail`\. A `container` read carrying the member holds as MAPI\-04's paragraph Console follow states and never polls, because each console read is a query to the provider\.

**Wait constants\.** This paragraph names the one home of the waits' figures\. One set of code constants holds the range, the poll, the polling stop, and the cap for the reads and the held acts, and the `container` wait's stop and its cap on followed consoles beside them\. The deploy command's progress read takes its stop from its route \(PLD\-L0\-86\)\.

**Retry checks\.** This paragraph qualifies MAPI\-04's paragraph Held acts' held acts and the first paragraph's retried call\. An answer to one of those acts that is not the platform's, an edge's error page or a closed connection among them, says nothing about whether the act was made\. The server's instructions \(MCP\-05\) and each act's description say so, and send the caller to the act's status read first, `read_status`, or `read_schedules` for `run_schedule`\. One of the four acts started only where its environment's `deploy` member names the kind of row the act starts, with a `started_at` later than the call\. A deploy's upload that `pending_upload` still names was not started, and its `retry` starts it\. Each of the four acts is repeated only where that read shows no start, and `run_schedule` only with the same `request_id`, as its own statement says\. What a repeat does stays each act's statement's to say\.

**Console follow\.** This paragraph extends MAPI\-04's paragraph Log waits' wait to a `container` read, which holds by following its console instead of polling\. Where the operator's `console_live_tail` is 1 \(PLD\-L0\-137\), the read takes the application's one held place first\. It then follows the console of each running instance of the serving compute and of a deploy's candidate, three at most, or of a pod's newest instance, beside the console store's read on the container grain\. It holds its answer until a followed or stored line the call's filters admit, stamped at or after its `since`, is read, or until MAPI\-04's paragraph Wait deadline's stop\. It answers as a `container` read does, every line its follows read merged in, with `waited_ms` and no `settled`\. Where nothing runs, or every follow has closed, it lists the instances once more ten seconds later and follows a newcomer, never listing a third time\.

**Follow bounds\.** This paragraph bounds MAPI\-04's paragraph Console follow's wait\. A process holds at most nine followed consoles beside the fifty held reads, and a wait following none counts one\. A wait that finds the switch at 0, the place taken, or the process's nine follows held answers at once as an ordinary `container` read, its `detail` naming which\. On the container grain, each listing reads the management API's remaining reads from its first answer; below fifty the wait answers at once with the lines read so far, and it lists a second time only where at least one hundred remain\. A deploy, a promote, and a roll back do not read that figure, so fifty is what a burst of waits leaves them\. The wait ends on the caller's close and at the process's shutdown, and each end closes every follow\.

This paragraph qualifies MAPI\-04's paragraph Console follow's hold on the pod grain\. A pod wait that finds no pod it has not already followed at its one more listing answers at once with the lines read so far, its `detail` saying no pod ran\. A pod wait whose last follow closes after its one more listing, as when the pod's process exits, answers at once with the lines read so far and no sentence on how it ended, since a pod's console ends with the pod\.

This paragraph qualifies MAPI\-04's paragraphs Console follow and Follow bounds for a `container` read answered from a failed check's kept lines \(PLD\-L0\-59\)\. That read reads the version row, not a console, so it takes no held place and answers at once, its `detail` saying so\.

**Schedule console\.** This paragraph qualifies MAPI\-04's paragraph Wait deadline's final read for `run_schedule`\. Its settled answer's console read, which SCH\-L0\-06 states, follows the final read, inside the same fifty seconds\. It is not made once the process has begun its shutdown or the caller's connection has closed, MAPI\-04's paragraph Read bounds' ends\. A read in flight when the shutdown begins ends by its own eight\-second bound, inside the shutdown's close budget\.

**Wait range\.** This paragraph qualifies MAPI\-04's paragraph Held reads' range and MAPI\-04's paragraph Wait deadline's refusal\. The range stops at 45 so that a held answer, its final read included, reaches the caller inside the sixty\-second request timeout the MCP SDK's client sets by default, which many tools keep\. A longer wait repeats a read, including the `next` call an act supplies\. A read returns once its condition is met; `read_logs` waits for entries to arrive or settle, and `read_usage` waits to its bound\. The MCP server's instructions state this reason once and tell a caller with a shorter tool timeout to pass fewer seconds, including on a returned `next` call\. The refusal's detail adds the same reason and the repeated read\. The deploy command waits through its own progress read, never through this member \(PLD\-L0\-86\)\.

This paragraph qualifies the first paragraph's clause that a reversible action completes in the call, for `halt_environment` on a pod environment\. Its halt completes in the call: the halt is written, and the hostname is refused within the routers' resolve interval\. The pod's stop follows the answer, after the wait PLD\-L0\-41 states\. It is read through `read_status`, whose `compute_state` reads `Running` while the pod holds a ready replica and `Idle` once it holds none\.

This paragraph extends MAPI\-04's paragraph Held acts' held act to `store_secret` with `replace: true`, whose `wait_seconds` rides `restart` true and holds the answer until the restart that member starts ends \(MAN\-14\)\. The hold is that restart's held act, polling, bounded, and placed as this statement states for `restart_application`, and the answer gives the restart's end in its `restart` member, never in its own `state`\.

**Request settling\.** This paragraph qualifies the read\_logs paragraph's hold for a read by the router's request id\. A held `read_logs` whose field is `request_id`, with no source or `all`, settles\. Past its first entry it waits until the `router` source and the `app` source have each answered\. Otherwise it ends at the first poll that finds no new entry once three seconds have passed since a poll first found one, longer than the logging client's two\-second flush\. Every other held `read_logs` answers once an entry arrives\.

MAPI\-24 \(decided\): A call an answer leaves its caller is named in `next` where the answer's owning statement gives it\. A call is left where the act's effect, or the caller's reading of the act's end, waits on it: a call that applies what the act, or its line, wrote, one a later act refuses without, or the read of work after the answer\. Where its owner gives the call, the answer carries it as `next`, an object of `action` and `arguments` the platform fills in whole, made as given \(PLD\-L0\-63; PLD\-L0\-84; PLD\-L0\-86; SCH\-L0\-06; MAN\-14; MAPI\-16; MAPI\-21\)\.

This paragraph qualifies the paragraph above for an action whose answer may leave several such calls\. Its `next` is always an array of those objects, one per call, in the order to make them, so a caller never branches on the member's type\. An action whose answer leaves at most one call carries the object alone\. An answer that leaves no call carries no `next`\.

This paragraph bounds the first paragraph\. An answer carries no `next` for a person's step, as a destructive action's approval is \(MAPI\-05\)\. It carries none for a call only some callers want, as a resubmission naming `local_run` is, since no answer knows whether a local run is wanted \(SEC\-L0\-07\)\. Its `detail` names such a step where the detail's budget keeps the line \(PLD\-L0\-39\), as it names advice on a next act after a complete one\. A call that follows a line applies only where the line did its act; where a line reports that nothing started, its printed refusal is the way on, and the answer's `next` does not apply \(PLD\-L0\-86; PLD\-L0\-94\)\.

This paragraph extends the first paragraph to a refusal\. A refusal whose remedy is one exact call may carry `next` naming that call, in the second paragraph's form for one call, the object alone\. It is filled in whole except a secret's value, which no `next` carries\. The refusal's detail stays as its owner states it, and its row of `schemas/wire_errors.json` declares the member \(MAPI\-15\)\. The first such refusal is `setting_secret_missing`: it carries the `store_secret` call for the target scope, naming the bound name, the application, and the environment the deploy or promote targets, and no value \(MAN\-14\)\. That call is the remedy that keeps the manifest as submitted, and the refusal's detail still names the other way, removing the binding, so the third paragraph's bound for a call only some callers want does not reach it\.

This paragraph names the members that share the name or the form\. A member named `next` inside another member keeps its own form: `provisioning.next` and `download.next` are sentences\. A refused start's `retry`, which `read_status`'s `pending_upload` carries, is a call of the same form under its own name \(MAPI\-04; PLD\-L0\-86\)\. `check_deploy`'s `without_command` is a call of the same form that its caller completes with its files \(PLD\-L0\-107\)\. It is no `next`, since the platform cannot fill it in whole, so the third paragraph's bound does not reach it, and `detail` still names the route\. `store_secret` with `replace: true`'s `restart` member carries in its own `next` a call of the same form\. That call is the one the answer's top\-level `next` names where both stand, or the `read_status` call that reads a restart it started that the request's `wait_seconds` did not see end \(MAN\-14\)\.

MAPI\-05 \(decided\): The pending action is a resource of this contract: a destructive action's request creates one, and its record carries Turn Zero Cloud's own description of what will be destroyed\. The one action that completes it — approval — is callable only by a signed\-in person's browser session \(WEB\-L0\-13\), a client restriction the enumeration states and the suite refuses violations of\. The requesting credential reads the record and its outcome; nothing but the browser approves\. The request's `request_id` member is the pending action's request identity \(MAPI\-04\): a string the caller chooses, matched by equality and never interpreted\.

A second request carrying the same `request_id`, from the same requesting account, for the same action, while the earlier record is live \(approved or executing, or requested and not past its expiry\), answers that record, its approval link included, and creates no second one\. A record that is no longer live — completed, failed, declined, expired, or requested and past its expiry — matches nothing, so the same `request_id` then starts a new pending action\. A request carrying no `request_id` is matched to no earlier request, each such call creating its own pending action\.

The match runs after the destructive request has passed the credential gates and its description has been produced, so a request that refuses by name refuses on every repeat and matches nothing\. The subject named by a repeat is not compared, the caller's identity being the caller's to keep distinct\. The durable store holds the match as one partial unique index over requesting account, action, and request identity on the live states\. A test in the platform's suite holds the match, the per\-account separation, the release after a decline, the unmatched case, and the lapsed case\.

A destructive door row the MCP front lists creates a pending action of this resource too \(MCP\-14; MCP\-07\)\. Its action is the row's prefixed name, its subject the product and the door tool, and its stored input the product, the tool, the arguments, and the token's label\. Its description is the product's own first\-party reading \(API\-L0\-07\), in place of Turn Zero Cloud's own description for a plane row\. The requesting credential reads it as any other\. Its request identity is the plane's own, since a door call carries no `request_id` the plane reads, so each such call creates its own pending action\.

`read_approval_status` with `brief: true` answers the record without its `description`, and its `outcome` with only its short values: booleans, numbers, nulls, and texts of at most 100 characters, such as `deleted` or a refusal's name\. A caller polling for the person's decision reads that form, and the whole read answers the receipts\.

MAPI\-06 \(decided\): Every action writes the append\-only operational record — actor, credential, action, subject, outcome, any confirmation, and, on a dispatched call's row, the reference the call's answer carries \(API\-L0\-19\) — from the first action of C2 onward\. **The credential is recorded as itself and not only as its kind**: its kind always, and its own identity wherever it has one, which an unattended token does and a browser session does not \(API\-L0\-05; MAPI\-03\)\. Without that, every act a credential performs is indistinguishable from every other act of the account that minted it, and an automated publish running unattended reads in the record as the person doing it by hand\. Telling the two apart is the one thing the record exists to be able to answer\.

The record is readable and exportable by no served surface: it exists so that the platform's own operation has a durable account of what was done, not so that a customer or an operator can query one\. Three readers inside the platform stand\. Two join on the record's reference column under an account and near the call's time, because the reference is not unique across the record's retention \(API\-L0\-19\)\. The third reads a named action's completed calls inside a window of time\. No served surface reads the record, and no export carries it\.

The daily pass's feedback step answers two bits for a report's quoted reference, whether such a row stands and whether it records a refusal, and never a row, and marks the report at the issue service \(PLD\-L0\-67\)\. A filing's stamp reads the action, the outcome, the build, and the code site of the filer's own call, or of a call of a batch its token seeded \(MAPI\-18\)\. The same step's exposure read answers each completed call of a fixed issue's action with its account, reference, instant, and build \(PLD\-L0\-67\)\.

Recording is never deferred to a reader's arrival, because a record that begins when a reader arrives is not a record, and it is buffered for at most one second\. Every action's record is appended to the plane's meter buffer as the action completes and flushed to the `action_records` table within one second or two hundred rows, after the caller is answered\. So a process end loses at most one flush interval of records, and no reader is ever the trigger \(CQ\-36\)\. The table is monthly range partitions dropped after twenty\-five months, every row carrying the environment\.

A row the store refuses loses that row alone\. A flush statement that fails twice is written again one row to a statement, and the rows the store refuses alone are dropped and reported once for the table in a flush, together with the table and their count\. Two cases drop a failed statement's rows whole, reported, with no row written alone\. One is a statement whose connection dropped after it was sent, because the store may already hold its rows\. The other is a store the plane could not reach across its failover window or within a checkout, because a row\-by\-row write would wait that out once for each row \(PLD\-L0\-67\)\. A store lost inside the row\-by\-row write ends it, and the row it failed on and the rows not yet written are dropped and reported together, with their count, in a report apart from the rows refused alone\.

The same buffer carries a gateway's usage rows, so calls a gateway answers from its held entries through a control\-database outage \(PLD\-L0\-67\) may go uncounted, and these reports are the one reading of how many\.

The logging feature package \(Q\-226\) owns the operational record once Turn Zero Cloud consumes it and the record writes through \(issue \#588\), and this statement is re\-parented to it then\.

MAPI\-07 \(decided\): A manifest change is the `submit_manifest` action on the application resource: validated against the manifest contract with refusals naming the failing path \(MAN\-12\), applied as one deliberate action, recorded like every action \(MAPI\-06\)\. Nothing else in the contract widens an application's declared reach, which is what ADM\-L0\-07's no\-side\-effect promise means here\.

MAPI\-08 \(decided\): The MCP tools are these actions, one to one and name for name: every tool of `schemas/mcp_surface.json` is an action of `schemas/management_api.json` at the same tier\. Every action callable by AI clients is a tool\. The approval action and a page's own actions, whose rows admit no bearer, are absent from the tool surface \(MAPI\-05; MAPI\-03\)\. The correspondence covers the call and not only the name: a tool declares the arguments its action accepts, derived from that action's request schema in `schemas/action_payloads.json`, so what a caller can express over the wire it can express as a tool\.

One exception, on answers, owned by SEC\-L0\-07: an application's standing credential value is answered on the wire surface alone\. So `submit_manifest` as a tool withholds its two value members and states `credentials: withheld`, and the two development re\-mints of `store_secret` with `replace: true` are refused as a tool, `local_route_required`, and answered on the wire\. Those tools declare the same arguments as their actions, save a member marked `x-wire-only`, and the difference is in the answer alone\. An exception to the listing rule, owned by MAPI\-16: the two rows the enumeration marks `switch: synthetic_estate` are listed as tools while the synthetic estate's posture, the control plane's setting `SYNTHETIC_ESTATE` \(MAPI\-16\), is not `off`\. They are unlisted while it is `off`, their wire routes standing and refusing `synthetic_estate_disabled` by name\.

An exception to the argument rule, owned by SCRT\-L0\-02 and CHI\-L0\-08 for a secret's value, by PLD\-L0\-86 for `deploy`'s members, by MAPI\-23 for `mint_token`'s, and by ACS\-L0\-21 for `sign_in_test_end_user`'s: a tool declares no request member marked `x-wire-only`, which the HTTP action route alone carries\. Those members are five the turnzero command alone names: `deploy`'s `zip_sha256`, `mint_token`'s `code_verifier` and `mint`, `store_secret` with `replace: true`'s `code_verifier` under a `provision` grant, and `sign_in_test_end_user`'s `delivery`\.

`store_secret`'s tool declares `value`, with or without `replace: true`, under SCRT\-L0\-02's one exception: a value the person already put in the conversation, which the transcript holds already\. The plane writes it as the HTTP action route does, with the same bounds, a name that stands at its scope re\-supplied as there, and never echoes or logs it\. A value on disk goes through the line, which never shows it to the assistant\. A `store_secret` tool call naming no value is the preparing form, save one naming `generate`, the creating write SEC\-L0\-20 states\. The platform\-minted names keep the answers above\.

A written replacement whose tool call carried `restart` or `wait_seconds`, which its tool does not take, starts no restart, and its answer's `note` says so\.

This paragraph adds two members to that exception, owned by MAN\-14, SEC\-L0\-19 refusing each under a grant: `store_secret` with `replace: true`'s `restart`, which restarts a running copy, and its `wait_seconds`, which holds the answer for that restart\. Each acts on the HTTP action route alone and on no tool call, so the tool declares neither\.

`create_application`'s `kind` carries no `x-wire-only` mark\. Its tool declares the optional member, `server` or `serverless`, and reads it as the HTTP action route does\. The turnzero command does not send it; it is outside the five members that command alone names\.

A `store_secret` call that names a name of the caller's own and no `value` or `generate` is the preparing form \(SEC\-L0\-19\)\. It is answered through the tool and on the HTTP action route under the caller's own bearer credential, and under the browser session it is refused `invalid_request`\. It writes nothing, mints a secret grant for the one write it names, and answers `state` as `awaiting_value`, `expires_at`, and the line that makes that write in its four forms \(PLD\-L0\-94\)\. A rotation's answer carries `next`, the `restart_application` call to make, where MAN\-14 names one\. The call may name `value_file`, the path the line reads the value from, which the tools declare, and a call naming it beside `value` is refused `invalid_request`\.

A `store_secret` call naming `generate` is no preparing form: it writes in the call on every surface and answers no value \(SEC\-L0\-20\)\. The `store_secret` tool declares `generate`, which carries no value, and refuses it beside `replace: true`\. A tool call that carried a `value` and named `generate` is refused as SEC\-L0\-20 states, not answered the preparing form\.

`code_verifier` is the code form's one member on `mint_token`, and `mint` the held form's, each read on the HTTP action route\. A `mint_token` call naming either anywhere else is refused as MAPI\-23 states, the MCP surface's refusal read through the mark as `deploy`'s handler reads `zip_sha256`\.

`delivery` is the one member of `sign_in_test_end_user` the turnzero command's `session` sends, read on the HTTP action route, and a call naming it anywhere else is refused `local_route_required` as ACS\-L0\-21 states, the MCP surface's refusal read through the mark as `deploy`'s handler reads `zip_sha256`\. Test end user actions have no statement of this document, ACS\-L0\-21 owning them\.

The suite holds the bijection and the argument derivation with it\. So the MCP surface cannot grow a capability this contract lacks, nor this contract an AI\-callable action the surface hides\. Nor can a tool's action take an argument the tool cannot carry, save a member marked `x-wire-only` that no setting opens to the tool, which the wire alone carries\.

MAPI\-09 \(decided\): The super\-admin's actions are enumeration rows like any other, marked `grant: super_admin`, the grant that exists only in Turn Zero's own accounts \(ACB\-L0\-71\), per credential and never by default\. A row carries one grant mark\. `super_admin` admits every grant\-marked row whichever grant marks it: the dispatcher's grant gate admits a credential holding the row's grant or `super_admin`\. The gate also admits a credential whose bounding grant the row's `admits` mark names \(MAPI\-16\)\. A credential holding a narrower grant alone reaches, among the grant\-marked rows, those marked with that grant, those whose `admits` mark names it where it bounds the credential, and no other\.

The operator set that carries `super_admin` is the control plane's setting `SUPER_ADMIN_IDENTITIES`, comma\-separated entries of the form `<provider>:<subject>`\. The provider is one of the builder realm's two federated providers, `google` and `github`, and the subject is the provider's stable subject as the realm's identity row stores it, never an address\. A process refuses its boot by name on an entry with no provider or no subject, a provider outside the two, or a subject carrying `@`\. A release meets that refusal at its readiness step, the prior revision still active \(PLD\-L0\-65\)\. Where every identity in the set has lost its sign\-in routes, the operator authority is restored by a new entry in the setting's committed row, released under the operator's sign\-in to the hosting subscription, which needs no operator credential\.

The grant a session carries is read live and stored on no user or session row\. Where a builder session, the dashboard cookie, or the browser action route resolves to a credential, the account's bound identities are read with the realm user's row\. The credential carries `super_admin` where one of them is in the set, unless the session's binding carries the bound `device_sign_in`, which withholds the grant whatever the set names \(MCP\-02; MAPI\-16\)\. An entry removed from the setting therefore ends that grant at the next request\. An operator token \(MAPI\-14\) keeps the grants its minting fixed while its account holds an identity in the set, and resolves to no credential while it holds none \(MAPI\-14\)\. So removing an entry from the setting refuses the person's operator tokens while their account holds no identity in the set\.

This paragraph states one unmarked row whose subject the grant widens\. `read_status` admits an application of any account under a credential holding `super_admin`, read\-only, so the operator's move reads the row it started \(PLD\-L0\-84\)\. Across accounts it withholds what the tenant's logs, manifest, and application wrote, the console lines, answer bodies, and refusal details of each row among them, and refuses `tables: true`, reaching no tenant data \(ADM\-L0\-10\)\.

Among the grant\-marked rows the grant admits those eight alone, and it bounds the token that carries it\. A minted token holding `synthetic_estate` and not `super_admin` is admitted to those eight rows, to the rows the enumeration marks `admits: ["synthetic_estate"]`, and to the rows marked `access: anonymous` \(MAPI\-11\), and is refused every other row of the account by name\. A token minted with both grants is `super_admin`'s and is bounded by nothing\. What the narrow grant reaches within each row, what within them stays `super_admin`'s alone, and the bound with its refusal, MAPI\-16 states\.

`feedback_queue`, the fifth grant, marks no row\. It is given on MAPI\-14's terms, bounds the token that carries it as MAPI\-16 states, and widens two unmarked rows, `read_feedback` and `settle_feedback` \(MAPI\-18; API\-L0\-20\), which carry it under `admits`, the grant decided at each handler\. The settling of the platform's own queue is the company's act on the platform's own record of its friction, naming no customer account and reaching no customer's data\. So a token holding the grant and not `super_admin` is admitted to those two rows and to the rows marked `access: anonymous` \(MAPI\-11\)\. It is refused every other row by name, the grant gate answering first on a row another grant marks \(MAPI\-14\)\.

Under the queue's grant the queue form, the whole read of any issue by its id, and the settling of an issue of the platform's own space answer, and the read with no member answers the operator account's own submissions \(MAPI\-18\)\. With `application`, `settle_feedback` settles an issue of the acting account's own application space with no grant read \(ITS\-L0\-03\)\. `issues`, the sixth grant, is a space grant any session of the account gives for one space it holds \(MAPI\-14\); it marks no row and bounds its token to the relay \(MAPI\-16\)\.

The grant\-marked rows are therefore thirty\-three in all, a `super_admin` credential reaching all thirty\-three, a `synthetic_estate` credential the eight, a `publication` credential the two, and a `feedback_queue` credential none, the grant marking no row\. `synthetic_seed_purge`, the seventh grant, marks no row either: a credential it bounds reaches three of the estate's eight by their `admits` mark \(MAPI\-16\)\. `tzmesh`, the eighth, is a product grant on `issues`'s pattern, given by any session of an account holding the `tzmesh` profile \(MAPI\-14\); it marks no row and bounds its token to `list_tokens`, `submit_feedback`, and the anonymous rows on this plane \(MAPI\-16\)\. `device_sign_in`, the tenth, is the bound of a session the device grant issued and no token's grant; it marks no row and reaches no grant\-marked row \(MCP\-02; MAPI\-16\)\.

Deleting a customer's account is not a further marked row\. It is the same `delete_account` action through the same pending action \(API\-L0\-07\), the grant widening the subject an operator credential may name and nothing else: same API, same tiers, same record, which is API\-L0\-12's whole claim\.

Administering the builder realm is not a further marked row either\. `invite_end_user` called with no `application` member, naming `email` or `invitation`, `list_invitations`, `application` optional, called with none, and `configure_app_sign_in` called with none address the builder realm \(ACS\-L0\-08; ACS\-L0\-07\)\. The three rows are unmarked, and that application\-less form is admitted to a credential holding `super_admin` alone\. It is refused by name to every other credential, and refused `token_scope_refused` to an application\-bounded token, the form naming no application the token is bound to \(API\-L0\-17\)\. So the grant widens the subject an operator credential may name on an unmarked row, the builder realm in place of a realm of the caller's own application, exactly as it does on `delete_account`\. The action record and the meter name the builder realm as the subject \(MAPI\-06\)\.

The queue form of `read_feedback`, the read called with `queue` \(MAPI\-18\), is the same pattern on a further unmarked row, the widening grant the queue's own\. The form is admitted to a credential holding `feedback_queue` or `super_admin`\. It is refused `grant_required` naming `feedback_queue` to every other credential that reaches the handler, and `token_scope_refused` to an application\-bounded token, the scope gate answering ahead of the handler in MAPI\-14's order\. The read without `queue` answers every credential its own submissions\. The read with `issue` answers a credential holding either grant any account's submission by its id and every other credential its own alone, another account's answered `not_found`\. The `super_admin`\-marked rows are twenty\-three, the `synthetic_estate`\-marked rows seven, the `publication`\-marked rows two, and no row carries `feedback_queue`, thirty\-two grant\-marked in all\. A test in the platform's suite holds each count: twenty\-three, seven, two, none, and thirty\-two\.

This statement records a use of MAPI\-02's shape clause on the action `add_product`, removed with its MCP tool, since no product is added to one account \(ACB\-L0\-76\)\. Over the actions route a call naming it answers 404 `unknown_action`, and the tool surface moves with MCP\-08's revision 7\. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, and `schemas/mcp_surface.json` move with it\. The coordinating session approved the removal under family:Q\-277, on Anthony's direction that no product is turned on or off per account\. The platform then held 81 builder accounts, synthetic accounts excluded, read from the control database at the change\.

`buy_credits` is an unmarked, reversible account row, addressed as `read_balance` is and admitting the bearer and browser\-session clients \(ACB\-L0\-101; ACB\-L0\-102\)\. It reads only the calling account, writes a purchase and calls the payment provider\. It opens checkout, takes no payment and needs no pending approval\. Each call starts a new purchase and ends the earlier open checkout, so it is not idempotent\. The row remains enumerated while credit sales are off; its handler then refuses `credit_sales_off`\. It adds no grant\-marked row to the inventory\.

MAPI\-10 \(decided\): The wire surface is uniform and derived: every action is an HTTP endpoint at the address its row's `surface` derives — POST for every tier, GET additionally for the observe tier — built from the enumeration at server start\. A route therefore exists exactly when its action does, which is MAPI\-01 enforced on the wire rather than reviewed onto it\.

The addresses are these\. An `account` row answers at `/api/v1/<action_name>` on the estate's origin, each registered from the enumeration and never as a prefix, since `/api/v1/` also holds the cookie address, the start\-line route, the account mail route and the support routes\. A `tzcloud` row answers at `/api/tzcloud/v1/<action_name>` and a plane\-made `tztrack` row at `/api/tztrack/v1/<action_name>`, the origin paths the edge forwards `tzcloud.turnzero.ai/v1/<action_name>` and `tztrack.turnzero.ai/v1/<action_name>` to\. Where an estate deliberately sets no host for an origin path, as the suites' local plane and any `TURNZERO_CLOUD_ORIGIN` do, the plane serves that path on its own origin \(PLD\-L0\-67\)\.

The HTTP action route, wherever a statement names it, is a row's address under a bearer credential\. Each of the three takes the bearer guard alone and admits no cookie, except the page\-only rows MAPI\-03 states\. A name of another surface, or a renamed one, answers `unknown_action` carrying `address`, the address that serves it or its successor\. Any other name answers `unknown_action` with no `address`, and a segment another route serves under `/api/v1/` is never read as a name\.

The cookie address is `/api/v1/actions/<action_name>`\. It stays served to the signed\-in site's cookie calls \(MAPI\-03; WEB\-L0\-16\) and to a request presenting no bearer credential\. A bearer call there answers 410 `action_address_moved`, carrying `address` and naming the action, from the Authorization header alone, so a presented value that resolves to nothing answers the same and the answer reads no credential\. The admission gate and the JSON body parser run ahead of it, as they do for any action\. Its detail names the update where the `User-Agent` starts with a command token \(PLD\-L0\-109\), as MAPI\-02 states for a retired name, and otherwise names the address and that a tool making the call needs its update\.

Every response carries the contract version \(MAPI\-02\)\. Every refusal is the wire error shape at `schemas/wire_error.schema.json`\. Its six base members are the version, a machine\-readable error slug, the action where one is in question, a human detail, the reference the action dispatcher minted for the call \(API\-L0\-19\), and `help`, the address of the refusal's explanation\. The reference is admitted and not required, as the action and the detail are, and it is carried by every refusal the action dispatcher answers to a dispatched call\.

`help` is admitted and not required\. It is carried by every refusal the action dispatcher answers to a dispatched call, and by the `unknown_action`, `method_not_allowed`, and `not_yet_provisioned` refusals the actions routes answer before dispatch\. It holds the address of the refusal's row on the refusals page, `<origin>/cloud/reference/refusals/#<refusal name>`, on the estate's configured public origin \(MCP\-02\)\. Where that origin is a loopback or an `http` one, the address is composed on the production origin instead, so a local run names the page production serves\.

Beyond the base members, on the management action surface, a refusal carries exactly the members its row of `schemas/wire_errors.json` names under `members` \(MAPI\-15\)\. Each is admitted and none is required, so a body that omits one stays valid\. A member no row names for that refusal is a defect of the body or of the row\. This is MAN\-12's named\-refusal discipline applied to the plane itself: a caller reads a violated path, a plan's floor, or a conflicting schedule as a typed member and never parses it out of the detail\.

A grant is one such member, `grant`, named and described by the row of each refusal that answers it\. Under `grant_required` it is the grant the action requires in the form called: a grant\-marked row's own, or the grant the statement owning that form names for it\. Under the other refusals it is the grant requested or held\.

The schema file's member region, its declarations beyond the base six and its conditionals, is generated from the rows and never written apart from them\. The file stays closed, declares every member any row names, and admits each under the refusals whose rows name it and under no other\. The platform's suite holds the file equal to its generation from the rows, and holds every refusal the action dispatcher answers under test to the file\.

This paragraph qualifies the member and suite\-check rules above for the refusals on the suite's closed list in MAPI\-15\. While that list holds a name, a listed body is checked against the six base members alone\. Extra members on a listed body are not violations, but a base member in the wrong form still is\. The five listed bodies with members of their own are held by the cases that answer them\. The schema stays generated from the catalogue rows that remain, and every other refusal keeps the whole rule\. The exception ends when the list is empty\.

Three rules hold on every surface a customer or a public caller reads, among them the router's and the egress gateway's own refusals, the version row's outcome read through `list_versions`, and a deletion walk's receipts read through `read_approval_status`\. A refusal a thrown transport failure produced — Node's `fetch failed`, whose deciding fact rides the error's cause — carries in its detail the message with the cause's code alone beside it, `fetch failed (ENOTFOUND)`\. It never carries the cause's message, which can name an address inside the platform's network\. A raw socket error is what `http.request` and `https.request` reject with, the router's application leg among them: its code is on the error itself with no cause, and its own message names the address the leg dialled\. It carries a fixed sentence with that code alone beside it, `the connection failed (ECONNREFUSED)`, and never its message\.

A refusal the provider answered is a status the management plane, a storage account, or the registry returned\. Its own message names the platform's subscription, a resource group, a request identifier, the registry's login server, or the provider's vocabulary\. On those surfaces it carries a fixed sentence with the status word alone beside it, `refused by the provider (http_403)`, or `failed (error)` where no status rode and no code of the transport's classifies, and never the provider's message\. An operator diagnostic — a control\-plane record, a run stamp, a command's standard error, the operator's own dashboard — carries the cause's code and message whole, a socket error's message whole, and the provider's message whole\. So a lookup a network blocked, a certificate a firewall replaced, and a right the platform's identity lacks each read as what they are and never as an outage\.

A thrown error whose transport code stands only along its cause, and whose own message is neither Node's `fetch failed` nor a raw socket error's, is the platform's own wrapper, its message composing an operator's text\. On those surfaces it carries the fixed sentence with that code alone, `the connection failed (ECONNRESET)`, and never its message\.

A container provision the provider failed because pulling the application's image answered 429 or a 5xx status is a refusal the provider answered, its message naming the registry's storage host and the provider's vocabulary\. On those surfaces it carries a fixed sentence naming the busy image registry with that status word alone beside it, `The image registry was busy (http_503)`, and never the provider's message\. The sentence says the fault is the platform's and transient, and names the act to call again\.

An unknown action refuses as `unknown_action`, never a bare 404 page\. A mutating action reached with GET refuses as `method_not_allowed`\. An action whose implementation has not arrived refuses as `not_yet_provisioned`\. The approval row's restriction \(MAPI\-05\) and a page\-only row's admission \(MAPI\-03\) are enforced at authentication, never by hiding the route\.

This statement records the seventy\-eighth use of that clause\. The row `declared_audience_contradicts_route` lost its member `routes` and gained `sign_in_methods`, admitted and not required, the same array of the realm's configured sign\-in methods under the realm member's new name \(ACS\-L0\-07; MAPI\-02\)\. The refusal keeps its name \(MAPI\-15\), the schema file's member region was generated again from the rows, and no other row's member changed\. The platform then held one builder account and no standing synthetic account, read at the change\.

This statement records a use of MAPI\-02's shape clause on `schemas/wire_errors.json`: the row `unknown_action` gains the member `address`, admitted and not required, the address that serves the named action or its successor, and the row `action_address_moved` is added\. `schemas/wire_error.schema.json`'s member region is generated again from the rows, and no other row's member changes\. The platform then held 6 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

ACB\-L0\-22 records the use of MAPI\-02's shape clause on `set_plan` and the plan members, and names the refusal rows that left the catalogue with them\.

MAPI\-22: **A call that names a member its action does not declare is refused by name, on every surface: the HTTP route, the tool surface, and the console\.** The refusal is `invalid_request`\. So a caller that misnames a member is told which member it sent, and is never answered as if it had sent none\.

What an action declares is the `properties` of its request in `schemas/action_payloads.json`\. A request's root is closed\. A nested object whose schema carries `properties`, empty or not, is closed too\. A nested object that carries none is a map and admits any member, and an array's items follow the same rule\. On the HTTP route a member of the query string counts as a member of the body\. A caller's `_origin` is refused, that member being the plane's own\.

The detail names what the caller sent and what the action takes\. It names each undeclared member, a nested one by its path, and then every member declared at that place, or their count as the paragraph on the budget states\. It quotes at most five undeclared names and counts the rest\. It quotes a name only where the name has a member's form, letters, digits, and underscores up to 64 characters\. It never carries a value\.

A member the contract replaced is answered with its successor\. A request may carry `x-renamed`, a map from a member the request once declared to the declared member that took its place, and the detail then adds a sentence naming that member\. A caller's guess gets no row\. The four feedback requests carry the map for `application` and `environment`, which `space` replaced \(MAPI\-18\)\. Their detail says which space a call naming none addresses, where the paragraph on the budget leaves `space`'s description whole\.

A member the contract removed, with no member in its place, is answered with the reason\. A request may carry `x-retired`, a map from a member the request once declared to a sentence that says why it is gone, and the detail then adds that sentence\. A nested member's row is keyed by its path, as the detail writes it, such as `routes[].body`\. On the tool surface a backticked action name in the sentence is named as the connection lists it \(MCP\-08\)\. `submit_feedback`'s request carries the map for `personal` and `excerpt`: its sentence says that a report has no personal option, and that the caller files again without the member and leaves out what it does not want kept \(MAPI\-18\)\. `request_route`'s carries it for `body`, at the top level and in `routes`: its sentence names `write_route` \(MAPI\-28\)\.

A member declared beneath the root is named where it stands\. Where a quoted name at the root is one the request neither replaced nor retired, and a member of the root declares it among its items' members or its own, the detail adds a sentence naming each such member\. The call is still refused, since the name stands at the wrong place\. On the tool surface a member marked `x-wire-only` is named in no such sentence\.

The detail holds MCP\-12's budget for a refusal's detail\. Where the names of the declared members would pass it, the detail gives each place's member count instead, with the address of the action's reference page, which lists them\. Where the address would pass the budget too, the detail gives the page's route without its origin\. Where the detail still passes the budget, a successor's description stops at its first sentence, and then the detail gives the successor's name alone\. Then it says only that the action's reference page lists them\. Last, the sentences naming where a quoted name is declared leave, the last first, since no rule rests on them\. The quoted names, the count of the rest, and each retired member's sentence always stay\.

The check stands in the dispatcher, behind its access gates\. It runs after the refusal of text the plane cannot hold \(PLD\-L0\-91\) and after every access gate: the scope, grant, and bound gates, and the destructive class's \(MAPI\-12\)\. So an access refusal keeps its name, and a credential the row does not admit is told no member names\. It runs before a pending act is described, so a refused call creates none\. Each surface hands the dispatcher the caller's member names and no value\. A body that is not a JSON object is refused at the same place, in words that name no member\. The replay of a stored input is not checked again\.

On the tool surface the refusal answers before the argument layer validates the call\. A single tool call that carries an undeclared member is handed to the dispatcher as the HTTP route hands a body\. So a call that misnames a required member is answered with the member it sent, not with the member it lacks\.

A single tool call with an object missing a declared required member is also handed to the dispatcher and refused naming each missing member; missing top\-level members, null values and objects reached through arrays keep the argument layer's answer\.

A batch of calls keeps the argument layer's order, and a request the transport refuses for its headers keeps that refusal\. The members the detail lists on this surface are the tool's arguments, a member marked `x-wire-only` left out \(MAPI\-08\)\. One exception stands: a tool call whose only member outside the tool's arguments is marked `x-wire-only` keeps the answer MAPI\-08 gives it\. A call that also names an undeclared member is refused by name\.

The served\-surface suite holds the rule for every action, on each surface that serves it\.

MAPI\-11: Action rows carry the access marking where MAPI\-09 carries the grant marking\. An action row marked anonymous stands outside every grant's bound \(MAPI\-16\) and needs no acting identity: the library’s inventory and content reads \(LC\-02\), and the platform context catalog and content reads \(CTX\-07\)\. On the wire every marked row, `read_library` and `read_context`, answers a request presenting no credential, or one resolving to no account, the challenge MCP\-02 states \(API\-L0\-15\)\. The one exception API\-L0\-15 names is an unmarked row: `search_documentation` answers a request presenting no bearer credential the signed\-out search CTX\-10 states\. Over MCP any connected identity reads it, since MCP\-02 challenges a connection presenting none\. An unmarked action answers as the connected identity behind the standard challenge \(the 401 pointing at the protected\-resource metadata, CQ\-189's machinery\)\.

The anonymous platform\_context observe actions additionally retain a supplied valid, active bearer or minted credential, checking the required OAuth scope where that credential is OAuth\-bound, for their credential\-filtered view and attribution\. On the wire and over MCP alike, a credential that resolves to an account without acting, suspended or unscoped, reads the anonymous view, and an absent or unresolved one draws the challenge \(MCP\-02\)\. Over MCP such a credential's message requiring an identity is refused 403\. A resolved platform credential, end\-user credential or transfer grant retains its named kind refusal\. The library HTTP routes take the same identity rule, a non\-acting account reading the library as any does\.

The marking is the enumeration’s own member: the server derives its authentication gate from it, the wire's marked rows challenging as the first paragraph states\. No surface keeps a hand\-curated set beside it, and the suite holds every action to a marking\-consistent gate \(Q\-239\)\.

MAPI\-12: The destructive class is granted by presence\. A session credential minted by a person's own browser sign\-in carries the destructive class from its minting — the sign\-in is the explicit grant API\-L0\-06 requires\. A minted token \(API\-L0\-05\) takes the class only at its own minting, from a session holding it \(MAPI\-14\), and from nothing afterward\. The application's platform credential \(SEC\-L0\-07\), the end\-user credential the accounts service issues, the transfer grant object storage mints, the secret grant \(SEC\-L0\-19\), and the egress key \(SEC\-L0\-18\) hold no destructive class and can be granted none\. A credential kind added later holds none until its own statement says otherwise \(API\-L0\-06\)\. The check runs where a destructive request arrives, before any pending action is created, and its refusal names the missing grant — a refusal distinct from the pending path, so an ungranted caller cannot fill a person's browser with approval requests\.

A token code \(MAPI\-23\) holds no destructive class and can be granted none; the token its exchange mints takes the class only as a minted token does, at the code's mint, from a session holding it\.

MAPI\-14: A minted token is created by `mint_token` \(reversible tier\), callable by the session credential alone — never by another token, the platform credential, or an anonymous caller — but for the fifteenth paragraph's exchange form\. A support read token is minted by the support consent route alone, and never by `mint_token` \(MAPI\-29\)\. Or, for a synthetic account alone, it is minted by the staff seed of synthetic accounts through the same code path under a credential the seed's row admits: a session holding `super_admin`, or a minted token carrying `synthetic_seed_purge`, `synthetic_estate`, or `super_admin` \(MAPI\-09\)\. So a harness holding a token carrying either synthetic grant mints the fixtures' tokens and no other \(MAPI\-16\)\.

`mint_token` names its scope \(the account, or one application of it\), an optional expiry, an optional label, the grants requested, and `code_challenge`, which is required\. Under the challenge the call mints a token code in place of the token and answers no value, and the optional boolean `authorized_computer` marks an authorized computer's token, each as the fifteenth and seventeenth paragraphs and MAPI\-23 state\. A call naming no `code_challenge`, or one of another form, is refused on each surface as MAPI\-23 states, nothing minted\. The destructive class \(MAPI\-12's explicit grant\) and `super_admin` \(MAPI\-09\) are each given only where the minting session holds it and refused by name otherwise\.

The seven narrow grants are `synthetic_seed_purge`, `synthetic_estate`, `publication`, `feedback_queue`, `issues`, `tzmesh`, and `tztrack`\. `synthetic_seed_purge` is the one the seed, the purge, and the purge's read admit \(MAPI\-16\), and `synthetic_estate` the one MAPI\-09 marks the synthetic estate's rows with\. `publication` is the one it marks the two publish rows with, `feedback_queue` the one `read_feedback` and `settle_feedback` admit \(MAPI\-18\), `issues` the space grant the next two paragraphs state, and `tzmesh` and `tztrack` the product grants two later paragraphs state\. Each bounds the token that carries it to the reach MAPI\-16 states\. The first four are given only where the minting session holds `super_admin` and refused by name otherwise\. At most one of the seven is given to a token that takes no `super_admin`, a request naming two refused 400 `invalid_request` with nothing minted\. None of `super_admin` and the seven narrow grants is given to an application\-bounded token \(API\-L0\-17\)\.

`issues` is given by any session of the account for one space the account holds, where the account holds the `tztrack` profile, the gate on the issue spaces \(ACB\-L0\-89\)\. The request names the space in `space`, a lower\-case UUID `list_issue_spaces` answers, the level in `level`, `report`, `contribute`, or `owner`, and a `label`, each required with the grant and refused `invalid_request` where absent; `space` or `level` without the grant is refused the same\. The label names the holder in printable characters, and no unrevoked token of the account carries it for the same space, expired or not, until the daily pass deletes the row \(PLD\-L0\-67\)\. A duplicate or a non\-printable label refuses `invalid_request`, and the level is not capped by the space's kind\. The relay names the acting actor as the account's identifier qualified by the label \(the issue service PRD's relay row\)\.

For a space shared with the account, `mint_token` refuses an `issues` grant above the account's membership level as `issues_level_refused`, naming that membership level\. At `view`, it refuses every `issues` grant for that space as `issues_level_refused` \(ITS\-L0\-07\)\.

Without the grant, a `space` naming a space the account does not hold is refused `space_not_owned` ahead of the form, the identifier judged before the form as every identifier is \(VER\-11\)\.

A space the account neither holds nor is a member of is refused 403 `space_not_owned` naming the space, whatever the session holds\. That is another account's unshared space, an unknown one, the platform's own space to every account but the one the plane names its owner, and an application's space until a binding records it \(the issue service PRD's relay row\)\. `space_not_owned` is this statement's row of `schemas/wire_errors.json` \(MAPI\-15\), answering the mint, the relay, and `create_space` under one name\.

The gate is read once the owner is judged\. An account that lacks the `tztrack` profile is refused 403 `blueprint_required` with nothing minted, whatever the space's kind\. On a shared space the owner's profile is read beside the member's, and a mint is refused the same where the owner lacks it \(ACB\-L0\-89\)\. The relay reads the same profile on each call, and `create_space` reads it before it creates anything \(the issue service PRD's relay and provisioning rows\)\. `blueprint_required` is ACB\-L0\-89's row of `schemas/wire_errors.json` \(MAPI\-15\)\.

`tzmesh` is given by any session of an account holding the `tzmesh` profile \(ACB\-L0\-76\), with a `label` naming the holder in printable characters, required and refused `invalid_request` where absent; `space` rides `issues` alone\. The grant takes no `level`: a call naming one with it is refused `invalid_request` with nothing minted, and the grant mints at the level `admin`, a mark that bounds no `tzmesh` call \(MAPI\-03\)\. A label may repeat across the account's `tzmesh` tokens, and `mint_token` refuses a non\-printable one `invalid_request`\. An account lacking the profile is refused 403 `tzmesh_required` with nothing minted\. The code's exchange reads the profile again and answers by that name, as MAPI\-23 states\. `list_tokens` and the mint's answer carry the level as `level`\. The token's expiry and its signed form are the paragraph after the operator token's\.

The exchange's answer carries the value exactly once beside the token's identity, and no `mint_token` call under a session credential answers a value on any surface \(API\-L0\-05\)\. The mint call's `token` member carries the properties the exchange mints with and no identity \(MAPI\-23\)\. The store holds the value's hash, the scope, the grants, the label, the revocation, and the authorized computer's marker, never the value\. It holds the three stamps — the minting, the expiry, and the last use, which the credential seam writes as it resolves a presented value — and a space grant's space and level\.

`revoke_token` \(reversible\) ends one token by its identity, and `list_tokens` \(observe\) answers identities, scopes, grants, labels, a space grant's space and level, and all three stamps, the last use among them, never values, and the exchange answers that shape for the token it mints\. `list_tokens` also answers `authorized_computer`, true on an authorized computer's token and false on every other\. On a `tzmesh` or `tztrack` token, it and the exchange also answer `last_used_note`, one sentence saying the last use counts only the requests this plane answers\. The product's own service checks such a token with no call to the plane \(MCP\-02\), so a null stamp there does not mean unused\. `revoke_token` is idempotent: a repeat answers the row with its first revocation stamp\. Once the daily pass has deleted the row, after the retention PLD\-L0\-67 states, `list_tokens` lists it no more and `revoke_token` naming it answers `not_found`\.

The exchange and `revoke_token` each write one line into the control plane's own diagnostics \(system:LGS\-L0\-16\) carrying the token's identity, its scope, its grants, its label, and its expiry, and never the value\. The mint call writes the line the nineteenth paragraph states, naming the code's identifier\. The fixtures the staff seed mints through the same code path write none, as do the sweeps an application's deletion and an account's erasure run, and the ends MCP\-02 states of the tokens an authorization exchange issued, each being another act's\. The operational record answers no reader \(MAPI\-06\), so that line is where an operator reads what was minted under an account and when it ended\. The `tzmesh` exchange's mint writes the same line, naming the client and the tokens its act revoked\.

A revoked or expired token is refused at once on the management surface and the MCP endpoint, and on the storage, egress, and logging wires at the gateways' next read past their cache interval \(PLD\-L0\-67\)\. A stored token whose grants name one outside the grants the running build serves resolves to no credential, refused `authentication_required` as an absent credential is\. So a build that predates a narrow grant never serves that grant's token unbounded\. A minted token renews nothing — it is replaced by minting another — and its grants admit nothing its minting session's grants did not admit \(MAPI\-09\)\. Every action a token performs is recorded under the token's own identity \(MAPI\-06\): a credential identity on the record beside the kind, empty where the credential has none\.

Its refusals run in one order, each named and none creating a pending action\. The scope comes first \(API\-L0\-17\)\. Then, on a row whose implementation has not arrived, comes `not_yet_provisioned` \(MAPI\-10\)\. Then comes the grant \(MAPI\-09\), under which a grant\-marked row that does not admit the token keeps `grant_required` with the row's own grant\. Then comes the bound of a token a narrow grant bounds, `synthetic_seed_purge_bounded`, `synthetic_estate_bounded`, `publication_bounded`, `feedback_queue_bounded`, `issues_bounded`, `tzmesh_bounded`, or `tztrack_bounded` by the grant \(MAPI\-16\)\. A session the device grant issued meets its bound at the same place, refused `device_sign_in_bounded` \(MAPI\-16\)\. The destructive class comes last \(MAPI\-12\)\.

This paragraph names the exchange, the first paragraph's one exception: `mint_token` on the HTTP action route under a token code the session's own call minted, which mints the token from the code's row and answers its value once, as MAPI\-23 states\. Its held form presents the verifier whose challenge the code recorded and names the mint by its id, as MAPI\-23 states too\.

The code's mint runs every refusal of this statement's mint before it mints, and the exchange reads again what the mint read, each as MAPI\-23 states\.

`authorized_computer`, an optional boolean, marks the token of an authorized computer, the one the turnzero command keeps on the computer whose challenge the call names \(PLD\-L0\-104\)\. The marked mint is made in two places through one function\. One is this call under a tool's session, which a signed\-in tool makes itself and then reports to the person\. The other is the computer login page under the browser session credential the approval cookie builds, where the person approves their own `login` \(WEB\-L0\-25; MAPI\-23\)\. A marked token is account\-scoped and lives at most 30 days, 30 where `expires_in_days` is absent\. A marked mint naming `scope_kind` `application` or `expires_in_days` above 30 is refused 400 `invalid_request` with nothing minted, the cap a refusal and never a clamp\. The exchange writes the marker on the token's row, and `revoke_token` ends the token as it ends any\.

This paragraph states `completion`, an optional tool argument of a marked mint, carried over MCP and the wire alike, whose one value is `mint` \(MAPI\-02; MAPI\-22\)\. An unmarked mint whose grants are `["tzmesh"]` alone takes it too, and asks by it for the held answer\. A marked mint made by a tool's session, over MCP or the HTTP action route, is answered the held line, which names the mint by its id and holds no code, whether or not it names the argument\. The computer login page's mint keeps its code outside its device mode \(WEB\-L0\-25\), as MAPI\-23 states\. The turnzero command's first act prints it among the call's members where it takes that line, and a tool names it only where that first act printed it\. Another value, or the argument on an unmarked mint this paragraph does not admit, is refused 400 `invalid_request` with nothing minted\.

The mint writes one line into the control plane's own diagnostics naming the code's identifier, the session's kind, the scope, the grants, the label, the marker, and the code's expiry, and no value\. The exchange writes the twelfth paragraph's line for the token it mints, naming the code's identifier beside the token's \(MAPI\-23\)\.

This paragraph and the next add the `tzmesh` exchange as the first paragraph's second exception \(MCP\-02\)\. The token endpoint's exchange, for a registered client that named the `tzmesh` resource, mints one signed `tzmesh` token at the level `admin` under the client's name, as MCP\-02 states\. It mints on the profile the paragraph on `tzmesh` states, read through the one rule \(ACB\-L0\-76\) at a tool's completion and again at the exchange\. An account lacking the profile is returned `access_denied` at the completion and refused `invalid_grant` at the exchange, no product word in either answer\.

The mint records the client the token was issued to and revokes, in the same act, each unrevoked `tzmesh` token of the account and label that client was issued, so a tool's earlier token is replaced and no other is\. Another token of the label, one `mint_token` minted or another client was issued, stands beside it, so a tool on a second computer leaves the first computer's token standing\. The token's value is the signed form MAPI\-03 states, answered once at the exchange, and it expires 180 days after its mint \(API\-L0\-05\)\. The exchange's end of a token it minted while the generation moved writes `revoke_token`'s line\.

This paragraph qualifies the two above for the `tzmesh` site's own sign\-in client \(MCP\-02\), whose sign\-in holds no page\. Its code exchanges for a `tzmesh` token at the level `chat` under the label `Sign-in at <host>`, the callback's host, with a life of one minute from its mint\. Its whole use is the service's exchange and its one `register_human` call\. Where a same\-origin post of the site started the sign\-in with an intent, its use also covers the one `register`, `attach`, `remove_listeners`, `delete_agent`, or public `create_channel` the callback makes in the service's own process\. The value is then dropped, never kept\. The replacement rule stands, so one unrevoked row of the label stands for the client per account\.

This paragraph qualifies the two paragraphs that add the `tzmesh` exchange for a builder's application, a request naming the scope `tzmesh.application` \(MCP\-02\), whose sign\-in holds one line at its first sign\-in to the client and no consent screen\. Its code exchanges for a `tzmesh` token at the level `chat`, issued to the client, under the label `<name> at <host>`, whose name, fallback name, and cut MCP\-02 states\. The token's life, the replacement rule, and the label rules stand as written\. The token's payload carries `application_sign_in` \(MAPI\-03\), which the `tzmesh` service reads as system:XTX\-02 states\.

This paragraph adds the device\-code exchange as the first paragraph's third exception \(MCP\-02; RFC 8628\)\. The token endpoint, under the grant `urn:ietf:params:oauth:grant-type:device_code`, answers a device code the person allowed on the verification page the resource's exchange answer\. For the `tzmesh` resource that is one signed `tzmesh` token at the level `admin` under the client's registered name, the two paragraphs that add the `tzmesh` exchange applying whole, the profile read again at the exchange\. For the `tztrack` resource it is the `tztrack` token the paragraph adding that exchange states\. For the plane's own resource it is the session the paragraph after the next states, which mints no token and is no exception of the first paragraph\.

The endpoint answers each device code once, deleting its row as it answers, so a second poll is refused `invalid_grant`\. Before the approval it answers `authorization_pending`, and a poll inside the interval `slow_down`\. A code past its ten minutes, allowed or not, is answered `expired_token`, and a cancelled request `access_denied`, each 400 by name\. A `client_id` no registration names is refused `invalid_client` ahead of the grant, and a device code of another client `invalid_grant`\.

This paragraph states the device grant's answer for the plane's own resource or a customer MCP address's \(MCP\-02\)\. The endpoint answers an allowed device code with the builder realm's session and its refresh token, as the authorization code's exchange answers one \(MCP\-10\), at the generation the verification page's sign\-in captured \(ACS\-L0\-11\)\. The session's binding carries the bounding grant `device_sign_in`, read as a bound at every seam MAPI\-16 names, and the session holds no `super_admin` whatever its account holds \(MAPI\-09\)\. The grant is no grant of `mint_token`'s list: a mint naming it is refused `invalid_request` as any grant outside the list is, as `support_read` is \(MAPI\-29\)\. A stored token row naming it resolves to no credential\. A device session calling `mint_token` is refused `device_sign_in_bounded` by the bound, so it mints nothing \(MAPI\-16\)\.

This paragraph adds the `tztrack` exchange as the first paragraph's fourth exception \(MCP\-02\), served where the plane names the tzTrack origin\. The token endpoint's exchange, for a registered client that named the tzTrack resource, mints one signed `tztrack` token at the level `admin` under the client's registered name, or `MCP client` where it registered none\. It reads the `tztrack` profile through the one rule at the exchange alone \(ACB\-L0\-76; ACB\-L0\-89\), no consent page standing: an account outside the gate is refused `invalid_grant`, no product word in the answer, and nothing minted\.

The mint records the client the token was issued to and revokes, in the same act, each unrevoked `tztrack` token of the account and label that client was issued; another token of the label stands beside it\. The token's value is the signed form MAPI\-03 states, answered once, and it expires 180 days after its mint \(API\-L0\-05\); its reach is MAPI\-16's\. The token takes the destructive class at that minting, since the sign\-in that holds the code is a person present, as a minted token takes the class at its own minting from a session holding it \(MAPI\-12; API\-L0\-06\)\. MAPI\-16's bound keeps the token to the rows admitting the grant, among which `delete_space` alone is destructive, and only the browser approves its pending action \(API\-L0\-07\)\. `list_tokens` lists the class among the token's grants\.

A request naming an application id that a live application of another account carries is refused 403 `application_other_account`, in `no_such_application`'s place, under every credential\. Every management action that resolves an application by its id answers it so, through the dispatcher's one path, and so does the storage surface's area declaration\. The refusal is recorded and metered under its own name \(MAPI\-06\)\. An id no live application carries is refused `no_such_application`, as each surface states\.

The refusal's detail opens by saying the application belongs to a different account than the one the request is signed in as\. It then names the acting account\. Under a marked token that is the account's sign\-in address, the address `read_account` answers a session as `address`\. Under every other credential, and where the address would carry the detail past its budget \(MCP\-12\), it is the account's id\. The detail closes with the likely cause: the turnzero command and the AI tool's connection are signed in to different accounts, so compare `whoami` with `read_account` over the connection\. The `whoami` line carries `--origin` where the origin is not the command's default \(PLD\-L0\-104\)\. Where no name fits the budget, the acting\-account sentence is left out\.

The detail names nothing of the account that holds the application: not its id, its address, or its name, nor the application's name\. It never says to log out, which would sign the command out of an account the person also uses\. The lookup that tells the two refusals apart is the store's read by id, unscoped by account, made on the refusal's path alone\. The refusal tells a caller that some account holds the id and nothing more\. An application id is a random UUID, and the edge's admission window bounds each source's requests \(PLD\-L0\-67\)\.

A refusal `no_such_application` answered under a marked token names the account the call acted as\. A management action and the storage surface's area declaration answer it so\. The detail keeps the surface's own sentence first and adds one, naming the acting account by its sign\-in address, or by the account's id where it has none or the address would carry the detail past its budget \(MCP\-12\)\. Under every other credential, and where neither fits the budget, the detail is the surface's sentence alone\.

An operator token is a minted token whose grants hold `super_admin` or a grant the mint gives only under it: `synthetic_seed_purge`, `synthetic_estate`, `publication`, or `feedback_queue`\. An operator token whose account holds no identity in the operator set \(MAPI\-09\) resolves to no credential\. It is refused `authentication_required` as a revoked token is\. Every process that can admit an operator token carries the operator\-set setting, and the internal service, which admits none, carries none\.

This paragraph states a product token's expiry and its form, one rule for each product grant\. The token lives at most 180 days, 180 where `expires_in_days` is absent; a mint naming more is refused 400 `invalid_request` with nothing minted, the cap a refusal and never a clamp, on the authorized computer's pattern\. The mint also reads the plane's origin for the product, and a mint on an estate naming none is refused 400 `invalid_request` with nothing minted\. The code's exchange mints the signed form MAPI\-03 states, signed by the accounts service under a single\-use ticket as MAPI\-23 states, and answers its value once\. `revoke_token` ends the token, whose row then stands on the product's revocation list \(MCP\-02\); `list_tokens` lists it with its level\.

`tztrack` is given by any session of an account holding the `tztrack` profile, the gate on the issue spaces \(ACB\-L0\-89\), with a `label` naming the holder in printable characters, required and refused `invalid_request` where absent; `space` rides `issues` alone\. The grant takes no `level`: a call naming one with it is refused `invalid_request` with nothing minted, and the grant mints at the level `admin`, a claim the product's service reads and bounds no call by, its permission levels coming from membership\. A label may repeat across the account's `tztrack` tokens, and `mint_token` refuses a non\-printable one `invalid_request`\. An account lacking the profile is refused 403 `blueprint_required` with nothing minted, the refusal naming no product; the code's exchange reads the profile again and answers it by its name, as MAPI\-23 states\. The token's expiry and form are the paragraph before this one's, and its reach MAPI\-16's\.

This paragraph adds `test_end_users`, a grant that bounds nothing\. A token carrying it keeps its scope's reach, and the grant admits it to the test end user acts on the realms where ACS\-L0\-21 refuses another minted token\. Any session of the account gives it, on an account token or a token bounded to one application, beside the destructive class, and beside `super_admin` on an account token\. It is refused 400 `invalid_request` with nothing minted beside any of the seven narrow grants, each bounding its token to rows that hold no realm act, and on a marked mint, whose members the command's first act prints\. `list_tokens` lists it in `grants`, beside the label, the scope, and the stamps\.

The `test_end_users` grant takes a `label`, required and refused `invalid_request` where absent, naming the holder in printable characters\. No unrevoked token of the account carrying the grant holds the same label for the same scope, the account or the one application, expired or not, until the daily pass deletes the row \(PLD\-L0\-67\)\. A taken or non\-printable label is refused `invalid_request` with nothing minted, at the mint, at the code's mint, and at the exchange \(MAPI\-23\)\. The token lives at most 180 days, 180 where `expires_in_days` is absent; a mint naming more is refused 400 `invalid_request` with nothing minted, the cap a refusal and never a clamp\.

This paragraph adds the support read grant to the thirteenth paragraph\. A token carrying `support_read` resolves to no credential on the management surface, the MCP endpoint, and the storage, egress, and logging wires, refused `authentication_required` as an absent credential is\. The support read routes alone admit it, the summary and the wider reads, each wider read running its named actions at the dispatcher's seam under the token: observe actions, and `relay_issue_act`'s `list`, `search`, and `read` alone \(MAPI\-29\)\.

The closing is written at every call because a listener a `tzmesh` token registered outlives the token, which a suspension or the exchange's replacement may already have revoked, or which may have expired \(MCP\-02\)\.

MAPI\-23: The token code is a one\-time grant every `mint_token` call under a session credential mints in place of a token, under the `code_challenge` the call names, admitted once at `mint_token`'s wire exchange form, where the exchange mints the token from the code's row\. So no `mint_token` call under a session credential answers a token's value on any surface: the exchange answers it once, to the command that holds the verifier \(API\-L0\-05; PLD\-L0\-104\)\. That command is the turnzero command, or tzTeam's `connect` where its first act made the challenge \(kit:GEN\-09\)\. The seed's once stands as MAPI\-16 states\.

The served descriptions carry the form's five members, `code_challenge`, `code_verifier`, `authorized_computer`, `completion`, and `mint`, and `mint_token`'s tool argument list carries `code_challenge`, `authorized_computer`, and `completion`, `code_verifier` and `mint` being the wire's alone \(MAPI\-08\)\. `mint` takes a row's id or `device`, the device poll's value\. The served value `token_code_seconds` \(PLD\-L0\-76\) gives every code but a device row its life, a device row living an hour, and the daily pass's step `token_codes_purged` \(PLD\-L0\-67\) removes the rows\.

Under a session credential a call names `code_challenge`, 43 base64url characters, the S256 challenge of a verifier the caller's turnzero command, or tzTeam's `connect`, holds, runs every refusal of the mint, and then mints one code in place of the token \(MAPI\-14\)\. The `issues` label rule is read from the account's token rows before anything is written, so a taken label is refused in the mint's words, no code minted\. On the wire a call naming no challenge, or one of another form, is refused 400 `invalid_request`, nothing minted, its detail naming the command's acts that print one \(PLD\-L0\-104\)\. Over the MCP surface the tool's shape names `code_challenge` required \(MAPI\-08\), so the transport's own validation refuses a call naming none before the handler, in the protocol's error shape naming the member, and a call naming one of another form meets the wire's refusal\.

The call answers 200 with the state `awaiting_command`, `command`, `command_windows`, `command_npx`, `command_npx_windows`, `expires_at`, the code's, `token`, and `detail`, and no value\. The computer login page makes the same mint under the browser session credential, through the one function this call's session mint runs, and shows its person no line \(WEB\-L0\-25; MAPI\-03\)\. Outside its device mode, its approval sends the browser to the command's loopback port with the code, or shows the code once where the address carries no port, the page still stands a few seconds on, or the browser runs no script\. `token` carries every property the exchange mints with, `scope_kind`, `application`, `grants`, `label`, `expires_at`, `authorized_computer`, and an `issues` token's `space` and `level`, and no `id` or stamps\. The token's expiry is fixed at the mint, from the days the call named, or 180 days for a product grant's code, or a `test_end_users` code, naming none \(MAPI\-14\)\.

This paragraph states a marked call's held answer\. A marked call over MCP or the HTTP action route answers it whether or not it names `completion` \(MAPI\-14\), and the computer login page's mint, outside its device mode, keeps the code\-carrying answer whose code the page reads \(WEB\-L0\-25\)\. The call then answers `command` as `turnzero authorize --mint <id>` whatever its grants, the row's id, which is no credential, in the four line forms, and no code; the value the mint made is answered to no one\. The `detail` says the line names the mint by its id and holds no credential, that the token is minted only when the command on the computer that printed the challenge presents its verifier, and to run it once, as given, there\.

This paragraph states an unmarked call's held answer, which a mint whose grants are `["tzmesh"]` alone asks for by naming `completion` as `mint` \(MAPI\-14\)\. The call answers `command` as `turnzero tzmesh register --mint <id>`, the row's id, in the four line forms, with no `--origin` on any estate, and no code; the value the mint made is answered to no one\. The `detail` says the line names the mint by its id and holds no credential, and that the token is minted only when the command on the computer that printed the challenge presents its verifier\. It says to run the line once on that computer, with the options that command's first act printed after it\. The held form redeems the row as it redeems a marked one\.

This paragraph states the device row, which the computer login page's device mode writes at its Approve for `turnzero login --device` \(WEB\-L0\-25; PLD\-L0\-104\)\. The page's mint names `completion` as `mint` and sets a field of the dispatcher's context that only the page sets and no route carries, so no member a tool names reaches it\. The handler reads that field on the page's own mint alone, and marks the row `device`, a mark no other mint sets, which the mint's control\-plane line names\. The row lives an hour from the Approve, never past the approving session's row, and its mint answers the held line, of which the page shows nothing, reading only that it carries no code\. A second Approve of a challenge whose newest device row stands unended and unexpired, by any account, is refused 400 `invalid_request` ahead of the label replacement, nothing minted and nothing ended\.

`command` is one line that pipes the code to the turnzero command on its standard input, in none of its arguments: the general mint's, `token claim`\. Outside device mode, the computer login page's own mint answers such a line naming `authorize`, which no command runs: the page reads the code from it and shows the line to no one \(WEB\-L0\-25\)\. It runs the installed command bare, `turnzero` \(PLD\-L0\-94\), and adds `--origin <origin>` where the estate's configured origin, never a host a request names, is not the command's default\. `command_windows` carries the line's Windows form, and `command_npx` and `command_npx_windows` its npx form \(PLD\-L0\-94\)\. The `token claim` line's `detail` says it is a credential until `expires_at`, to run once, as given, and paste into nothing but the terminal that runs it\. It says the person runs it, in a terminal outside the AI coding tool, and never a tool\.

The `detail` also names the one exception: tzTeam's `connect`, whose first act made the challenge, runs its own completing line with the code \(PLD\-L0\-104\)\.

A token code is a grant of a kind of its own, the third beside the transfer grant and the secret grant, and its value has a grant's form \(MAPI\-03\)\. Its record kind, on the action record, the authorization matrix, and the credential\-surface census, is `token_code`\. The plane stores it by its SHA\-256 alone, in the control database's `token_codes` table \(PLD\-L0\-67\)\. Its row records the account, the minting session's kind and row key, which no record, answer, or log line carries, the challenge, every property the mint named, the marker, and the device mark\. It also records the token's expiry, the code's creation and expiry, the instant and manner of its end, and the token it minted\. A partial index over the device rows serves the reads by challenge\.

A code lasts the served `token_code_seconds`, 300 seconds by default and held between 30 and 300 \(PLD\-L0\-76\), and a device row an hour, each never past the minting session's row's expiry\. A later mint by the same session under the same label ends that session's unspent codes of the label, passing over its device rows\.

The exchange is `mint_token` on the HTTP action route with the code as its bearer and the body `code_verifier` and no other member\. There the dispatcher's kind gate looks the code up and spends it by one compare\-and\-set bounded by its expiry, ahead of every refusal of its own and ahead of the verifier's match\. So every presentation there of a code the plane holds unspent spends it, whatever the call then answers, and two presentations of one code are admitted once\.

The held form is `mint_token` on the HTTP action route with the verifier as its bearer, of the verifier's form and no credential prefix, and the body `mint` alone, the row's id\. The form follows the bearer and the body: a grant\-form bearer takes the code form, and a verifier\-form bearer naming `mint` the held form\. There the kind gate reads the row by its id\. A body naming more than `mint`, a row absent, ended, or expired, or a challenge that is not the bearer's S256 hash is the one refusal with nothing spent, the id being public\. A match spends the row by the one compare\-and\-set, a spend another presentation took being the refusal\. Then the account's standing and the minting session's row are read as the code form reads them, each failure the refusal with the row spent, and the exchange mints as the code form does\.

The held form's `mint` also takes `device`, the device poll of `turnzero login --device`\. There the kind gate reads the newest device row of the bearer's S256 hash, whatever its end, and judges it as it judges a row named by its id\. A device row named by its id is the one refusal, nothing spent\. The poll reads device rows alone, so a `token request` or `authorize` row under the same challenge is never redeemed by it\.

The device poll before the Approve finds no device row of its challenge, and is answered 400 `authorization_pending` with a `detail` saying no one has approved the sign\-in, nothing was minted, and to poll again in five seconds until the request's `expires_at`\. The answer writes no action record and no meter row, as a bearer that resolves to nothing writes none, since the poll names no row and repeats while it waits\. `authorization_pending` is a row of `schemas/wire_errors.json` that this statement and MCP\-02 answer \(MAPI\-15\)\.

The plane mints the token where the verifier's S256 challenge is the recorded challenge, the account is not suspended, and the minting session's own row stands unrevoked, unexpired, and not behind its account's generation\. That one read covers sign\-out everywhere, `revoke_token` with `connection`, and the client's own revocation at the revocation endpoint \(MCP\-02\)\. It also covers a device's sign\-out, a passkey change's revert, and the session's expiry\.

The exchange also reads again what the mint read: an application\-scoped code's application, an `issues` code's space, `tztrack` profile \(ACB\-L0\-89\), and label, a `tzmesh` code's profile, a `tztrack` code's profile, and a product code's origin\. Where the account no longer holds the application, the space, or either profile, or an unrevoked token has taken an `issues` code's label since the mint, the exchange answers the standing mint's refusal\. That is `no_such_application`, `space_not_owned`, `blueprint_required`, `tzmesh_required`, or `invalid_request`, the code spent and nothing minted\. A fault reading the space is answered as the standing mint answers it, and any other fault is the dispatcher's internal failure\.

This paragraph adds the `test_end_users` grant's label rule \(MAPI\-14\) beside the `issues` one\. The code's mint reads it from the account's token rows for the code's scope before anything is written, a taken label refused in the mint's words with no code minted\. The exchange meets it again at the store's insert, a label taken since the mint refused `invalid_request` with the code spent and nothing minted\.

It mints with the recorded properties and the marker, writes the token's identity on the code's row, and answers 200 with `token`, the identity beside the same shape, and `value`, to that one caller, and no later read shows the value\.

A product code's exchange mints the signed form MAPI\-03 states\. The management service holds no signing key \(SEC\-L0\-07\), so the exchange writes a single\-use ticket of kind `product_token` into the shared tickets store \(PLD\-L0\-67\), naming the account, the product, the label, the level `admin`, the token's identity, and its expiry\. It posts the ticket with the account to the accounts service's route `/accounts/v0/<product>/token`, which takes the ticket once, signs under the product's realm, and answers the value\. The route refuses a ticket absent, spent, expired, or naming another account or product 403 `product_ticket_refused`, and a build naming no origin for the product answers 404 `not_found`\. A process holding the keys signs in\-process and writes no ticket, as the erasure walk's member does \(ACB\-L0\-47\)\.

The exchange stores the value's hash and the product on the token's row and answers the value once, as for every token\. The route's 503 `realm_keys_unready` is answered by name at the exchange, the code spent and nothing minted, and the person mints again\. The ticket lives one minute, is discarded with the answer, and is purged with the table's other kinds \(PLD\-L0\-67\)\.

One refusal answers every other state: 403 `token_code_refused`, alike in name, status, and detail, each answer carrying its own `reference` \(MAPI\-10\)\. The states are an unknown, spent, expired, or ended code or device row; a body naming more than the verifier; an unmatched verifier, or one outside its form; and a code of a suspended account or an ended session\. So is a bearer of a grant's form that resolves to nothing there\. A mismatch, or a verifier outside its form, spends the code, so a copy presented without the verifier mints nothing, and the person's own line is then refused and told to call `mint_token` again\. The detail says the code cannot be used, being unknown, expired, or already presented, its verifier unmatched, its account suspended, or its session ended, that nothing was minted, and the remedy\. `token_code_refused` is this statement's row of `schemas/wire_errors.json` \(MAPI\-15\)\.

Every presentation at the exchange form and the held form, a device poll among them, counts in its source's admission window ahead of the lookup, whether or not the plane holds the code \(PLD\-L0\-67\)\. So the gate's 429 `rate_capped` alone precedes the spend and leaves a found code unspent\. A transfer grant or a secret grant presented there is answered as MAPI\-03 states and stays unspent\. Elsewhere a code is no credential: on every other management action, on `mint_token`'s other forms, on the MCP surface, and on the storage and egress wires it is answered as a value of a grant's form that resolves to no credential is \(MAPI\-03\), unspent\.

`code_verifier` is a wire\-only member \(MAPI\-08\): an MCP call naming it beside a challenge is refused 409 `local_route_required`, and a wire call to `mint_token` naming it under any credential but a token code 400 `invalid_request`, nothing minted\. `store_secret` with `replace: true` reads it under a `provision` grant alone \(SEC\-L0\-19\)\. An MCP call naming it with no challenge meets the shape's own refusal first\. A token code holds no destructive class \(MAPI\-12\)\. `mint` is the wire's alone the same way, an MCP call naming it refused 409 `local_route_required` and a wire call under any credential but a token code or a verifier at the held form 400 `invalid_request`, nothing minted\. Under a token code a body naming `code_verifier` beside it is the code form's refusal, the code spent; one naming no `code_verifier` resolves to no credential, unspent\. `completion` is a tool argument, carried over MCP and the wire alike \(MAPI\-14\)\.

A code ends with its one presentation, its expiry, a later `mint_token` by the same session under the same label, a device row excepted, and the account's `sign_out_everywhere`, a passkey change's revert, and suspension; the account's erasure removes the rows \(PLD\-L0\-66\)\. `revoke_token` with `connection`, the client's own revocation at the revocation endpoint \(MCP\-02\), a device's sign\-out, and the session's expiry write no end on the code\. The exchange refuses such a code by its read of the session's row\. A reinstatement brings no ended code back\. The daily pass's step `token_codes_purged` deletes each code a day past its expiry \(PLD\-L0\-67\)\.

The mint's action record names the session's kind and the code's identifier and holds no part of the answer\. The page's mint writes the same record and the same control\-plane line, its session kind the browser session's\. The exchange's record is attributed to the owning account with the code's kind and identifier, and names the token minted\. A refused presentation of a code the plane holds is recorded against its identifier, and one of a value it does not hold with no value\. The mint and the exchange each write one control\-plane line, the mint's naming the code's identifier and the exchange's the token's and the code's \(MAPI\-14\)\. No code, verifier, or token value stands in any record, event, or log line, and no hash of a refused value is logged \(system:SCRT\-L0\-02\); the challenge may stand on the code's row, since it is public\.

At the launch population \(PLD\-L0\-74\) the `token_codes` table holds about a day's mints, tens of thousands of rows, and `minted_tokens` gains one live row per authorized computer and origin, about 900,000 rows inside the thirty\-day retention at 300,000 accounts\. The marker is one nullable column with no index, read as a token is read today\. The pass's delete reads `expires_at`, which no index serves, an index owed at the next order\.

The device mark is one boolean column with a constant default, and the partial index on a device row's challenge and creation holds the device rows alone, a small share of the table\. A waiting command polls every five seconds, about 720 polls in its hour, each about three statements: the guard's two lookups and the one probe of that index\. At 300,000 accounts, if one in a hundred signed in by device each day and waited ten minutes, the polls would ask about 12 statements a second, an estimate\. At two million accounts the same share asks about 80, each an index probe on the control database, which needs no change of unit\.

MAPI\-19: The `connection` resource is a signed\-in tool's OAuth 2\.1 refresh family \(API\-L0\-21; MCP\-10\), one per sign\-in a registered client completed, and the account grain holds its two acts\. `list_tokens` \(observe\) answers the acting account's live connections\. Each row is its identity, its client, the instant of the sign\-in that opened it, its last renewal or null, and its expiry, and never a credential value or hash\. The listing is idempotent and answers GET as every observe row does \(MAPI\-10\)\. `revoke_token` with `connection` \(reversible\) ends the connection that member names: the family's refresh credentials are deleted and its access\-token session rows revoked, so the tool is refused at once on the management surface, the MCP endpoint, and the wires alike\. It touches no other connection, cookie, or minted token\. A `connection` no live family of the acting account carries is refused 404 `not_found`, another account's among them\.

`list_tokens` and `revoke_token` with `connection` are callable by the session credential and by the browser session \(MAPI\-03; MAPI\-05\), and by a minted token as MAPI\-03 admits an account act\. The Connected AI tools page's Connected tools section lists and ends the rows \(WEB\-L0\-21\), and the home reads the list for its card alone \(WEB\-L0\-17\)\. Neither is grant\-marked \(MAPI\-09\)\. Each end writes one line into the control plane's own diagnostics carrying the account, the client, and the family, never a token \(system:LGS\-L0\-16\)\.

The row `sign_out_everywhere` \(reversible\), on the `account` resource under the same callers and no grant mark, ends every session and every connection of the account at once and answers `sessions_ended`, `refresh_rows_deleted`, and `exchange_tokens_revoked`\. The last counts the tokens an authorization exchange issued the account that it ended, the `tzmesh` exchange's and those the retired client `turnzero-blueprint` was issued \(MCP\-02; ACS\-L0\-18\)\. The site's Sign out ends that browser's session alone\.

A token a narrow grant bounds is answered its tokens alone, no connection among them \(MCP\-08\)\.

MAPI\-15: The refusal names are enumerated\. Every refusal name a surface of the plane answers is listed once in `schemas/wire_errors.json` beside this document\. Each row carries the surfaces that answer it, the HTTP status where one status is fixed across every site, and the statement that owns the behaviour\. It also carries one clause saying when it is answered and one clause saying what the caller does next, the row's remedy, written by the change that adds the row\. The surfaces are the management actions on their routes and through the tools that surface them \(MAPI\-08\), and the MCP server's own challenge\. The others are these:<br>\- object storage;<br>\- the egress gateway;<br>\- the push service's send route;<br>\- the email service's send route;<br>\- the accounts service's realm surface;<br>\- the builder sign\-in;<br>\- the serving router;<br>\- the deploy command's progress read, the catalogue's `deploy_progress` \(PLD\-L0\-86\)\.

This paragraph qualifies the catalogue's refusal rules while the suite's closed list of refusals answered by the plans path alone holds a name\. A refusal on that sorted closed list may remain outside the catalogue\. Each listed name must still be answered by the source and absent from the catalogue\. Any other name answered without a row still fails the suite\. The exception ends when the list is empty\.

Four more surfaces answer names of the list: the egress tunnel seat \(`egress_tunnel`\), the logging ingest \(`logging`\), the runner harness inside every application container \(`harness`\), and the documentation trees' machine files \(`documentation`\)\.

Where the refusal's body on the management action surface carries members beyond the six base members \(MAPI\-10\), the row carries a `members` object giving each member's name a JSON Schema fragment that types and describes it\. The published refusals page reads both clauses and the members from the row and derives none of them\. Each clause is written in sentences of fewer than 45 words, because the page carries them as table cells under the documentation's prose bound, a member's description held to the same bound for the same reason\.

A row's `members` state the body the management action surface answers and nothing of another surface's body under the same name, so a row that does not name that surface carries none\. The rows and the schema generated from them state the management action surface's refusal bodies alone\. The body another surface answers under a name of this list is that surface's owning statement's to state, in the shape the surface answers, and no row, schema, or description of this catalogue holds it to the management action surface's shape\.

The rows are the members' one home\. A fragment uses `type`, `items`, `properties`, `pattern`, and `description` alone, through its nested fragments, and never an enumeration, a constant, a format, or a required list\. It never uses them because a closed vocabulary in a fragment would make every later value a change of the body's shape and because every member is admitted and none required\. A member that may be null says so in its `type`, and a nested object declares the properties the platform answers and stays open\.

The list is derived from nothing and reviewed onto nothing\. A test in the platform's suite extracts the names from the source by the call forms the surfaces use to put a name on the wire and holds the two sets equal\. So a name the source answers that the list lacks, and a row the source no longer answers, each fail the suite\. A name absent from the list is a defect in the change that added it, closed by adding the row in the same change, never by excluding a real wire form from extraction\. When the implementation introduces another way to carry a refusal name on the wire, the extractor covers that form and the catalogue gains any new names in the same change\.

The JSON body shape stays MAPI\-10's \(`schemas/wire_error.schema.json`\), whose member region is generated from the rows' `members`\. The suite holds each row's members to this form and each declared member's name to a key the platform source writes at a site that builds that refusal's body\. So a member the rows declare and no site of that refusal still writes fails it, as a row the source no longer answers does\. This catalogue includes the JSON `error` member's values and standard OAuth `error` parameters in WWW\-Authenticate challenge headers and authorization redirects; it does not impose the JSON body shape on those standard protocol fields\. This is MAN\-12's named\-refusal discipline made a check\. Within a contract version the list grows and never shrinks: retiring a name is a new contract version \(MAPI\-02\)\.

One case stands beside that rule while MAPI\-02's under\-one\-hundred\-accounts clause stands\. A name the source stops answering because its cause has left the platform may leave the list within version 1, recorded as MAPI\-02 records a use of that clause, with the account count read at the change\.

The members' evolution is MAPI\-02's and no rule of this statement's own\. While its under\-one\-hundred\-accounts clause stands, a member added to a row, a member removed from one, and a fragment's typing changed, its `type`, `items`, `properties`, or `pattern`, are each a change of the body's shape, recorded by MAPI\-10 as a use of that clause\. A description's wording is a content change that moves the version and no use\. Once it lapses, a member added is a new optional field, and a member removed or a fragment's typing narrowed is a new contract version\.

A row's owner is the one statement that states its behaviour\. A name several statements answer names none, its surfaces and summary saying where and why: `access_denied`, `account_picture_not_yet_served`, `account_picture_unavailable`, `authentication_required`, `authorization_pending`, `browser_session_required`, `invalid_request`, `not_configured`, `not_found`, `no_such_application`, `origin_not_admitted`, `publish_incomplete` and `publish_not_forward` are such names\. A row whose behaviour no statement states yet carries none until a statement states it\.

The `builder_sign_in` surface also includes `/accounts/v0/tzmesh/site-token` \(ACS\-L0\-18\)\. It answers `origin_not_admitted` for an absent or unmatched origin, `account_suspended` for a suspended account, and `access_denied` where the one rule answers no `tzmesh` profile \(ACB\-L0\-76\)\. The catalogue's rows include that surface and those causes; the route's bodies remain ACS\-L0\-18's, under the surface\-shape rule above\.

The `dashboard_picture` surface is `GET /dashboard/account-picture`, the dashboard credential's picture read \(WEB\-L0\-27\)\. Its four ordinary refusals carry JSON `error` and `detail`; its admission refusal also carries `contract_version: 1`\. A thrown error returns the router's 500 HTML failure page, not a refusal name\. WEB\-L0\-27 owns these response bodies\.

MAPI\-13: The running build states its identity on the health read\. The artifact carries a build stamp written at bundle time — the source commit, whether the tree was dirty, and the build instant — as a stamp file beside the bundle\. `GET /healthz` answers it as `build` beside MAPI\-02's `contract_version`\. Beside the stamp's three members, `build` carries `bundle_hash`, the SHA\-256 of what the process's image copies: the one bundle file for the serving router and the tunnel seat, and for the plane the `dist/` tree its image copies whole\. For that tree the hash reads every file under the folder holding the bundle, each relative path joined with `/`, the paths sorted by bytes, each path then its file's bytes fed to one hash, `build.json` and the bundle's source map excluded\.

`bundle_hash` is read at the process's boot from the file it runs as `harness_hash` is, and it is null where the process does not run from its image's file\. Beside `build`, `/healthz` answers `harness_hash`, the SHA\-256 of the runner harness bundle beside the running bundle, the harness the platform bakes into every application image it builds \(PLD\-L0\-63\)\. A source tree with no stamp answers null members, never an invented value, and a process with no harness bundle beside it answers `harness_hash` null the same way\.

Beside `build`, `/healthz` answers `wire`, the plane's served wire: for each served schema file `schemas/served_context.json` names that carries a top\-level `version`, that version keyed by the file's name without `.json`, composed once at the process's boot\. It is read by the turnzero command once per run, before its first request, to check the plane it addresses, and by the command's publish workflow, which checks the command's declaration against each estate's wire before it publishes\.

Beside `wire`, `/healthz` answers `command_latest`, the turnzero command's latest release as `<major>.<minor>.<patch>`, where the plane knows it\. It is the release the estate's tag names in the public npm registry's dist\-tags, `latest` on production's origin and `next` on any other, a pre\-release counted as the release it is cut from\. A serving process that mounts the management set reads it at most once an hour beside the answer that asks, never per request, each read bounded at three seconds\. A failed read keeps the last value read, and where no read has succeeded the member is absent\. The command reads it with `wire`, before its first request, so it can name a newer release before any call meets the floor \(PLD\-L0\-94; PLD\-L0\-109\)\.

Beside `command_latest`, `/healthz` answers `opened`, the products' openings as the process last read the served settings \(PLD\-L0\-76\)\. `tzmesh` and `tzteam` are each true where the setting `invite_only_products` did not name it, and `tztrack` is true, every account holding it \(ACB\-L0\-76\)\. It is the reading the process's own setting reader holds, and the health read starts none, so where no reading has succeeded the member is absent\. The site publish reads it from the estate it publishes to, so the open trees it lists follow the estate's own setting \(PLD\-L0\-75\)\. Where the member is absent, or does not name a product, the publish reads that product as the default invite\-only list opens it\.

The identity answers on that one anonymous read rather than riding every exchange\. It also answers on two aliases the edge's standing routes carry to the services its default route does not reach: `GET /accounts/v0/healthz` on the accounts mount set and `GET /logging/v0/healthz` on the gateways mount set\. Each answers the body `/healthz` answers, read through the edge under the origin lock's check where `/healthz` itself is exempt \(PLD\-L0\-67\)\. So two builds of one contract are distinguishable to any caller at the cost of one call, and a deploy's completion is the served identity changing to the deployed commit \(PLD\-L0\-65; the handshake SVC\-L0\-11 asks of a customer's backend, kept by the plane itself\)\.

The build also states its readiness on `GET /readyz`: one statement per database pool the process holds\. It answers 200 with `ready` true, `pools` naming each pool with `ok`, and `unapplied` 0, or 503 with `ready` false, `pools` naming the pool that failed, `unapplied` counting the migration files the ledger lacks, and `detail`\. The answer carries them beside MAPI\-02's `contract_version` and `build`, the member `/healthz` answers, so the one readiness read carries the process's identity\.

On the accounts mount set the answer also carries `realm_keys`, ready once the realm key\-encryption key is unwrapped \(SEC\-L0\-07\)\. A process holding no pool answers ready with an empty `pools`\.

On a process mounting the gateways set alone, a control pool whose statement failed while the credential cache holds an entry within its stale ceiling answers 200 with `ready` true, that pool `failed` in `pools`, and `serving_stale` true\. The wires answer from the held entries \(PLD\-L0\-67's cache rule\)\. The migration status read fails with that pool and refuses nothing while the answer is `serving_stale`, whose `unapplied` reads 0 whether or not a ledger was read, and every other failed statement refuses as stated\.

On that process the control pool's check and the status read each have a bound under the host's probe timeout, so a connection that hangs does not outlast the probe\. A control pool past it reads as failed\. A status read past it refuses only until the process has read the status clean\. After a background answer names an unapplied file, it refuses again until the process reads clean\. Otherwise a saturated pool does not take a busy replica out of traffic\.

On every process, a migration status reading with no unapplied file is held with its instant\. Until that reading is cleared, a readiness probe reads no ledger and waits on no status read; `unapplied` is 0\. A probe at least five minutes after its instant starts one background read, at most one counted in flight per process\. A read still open five minutes after it started is no longer counted in flight\. A late answer applies unless a read started later has already answered\. A clean answer renews the instant; an answer naming an unapplied file clears the reading, so the next probe reads the ledgers under the preceding rules\. A failed background read refuses nothing, writes `readiness migration status read failed` at `info`, and renews the instant so another full interval passes before a retry\.

On a build that mounts the gateways set, `GET /healthz` also answers `caches`: for each gateway cache, `credential` and `rows` \(PLD\-L0\-67\), the positive and negative entries held and the hits, misses, and stale serves counted since the process started, read from the process alone\. The health read stays the identity read and touches no store, so a host's liveness probe and its readiness probe ask different questions \(PLD\-L0\-67\)\.

The process binds its listener before it builds its routes\. A connection attempted before the bind is refused at the socket\. A request accepted after the bind and before startup completes, a liveness or readiness probe included, is held unanswered until the routes are built and the pre\-serve work the entry runs for its mount set has completed \(PLD\-L0\-67\)\. That work is the timers' start and, on the management set, the first sweeps; the request is then served by the built application\. Where that work fails after the bind, no held request is answered, each held connection is destroyed, the listener closes, and the startup call fails with the error, which ends the executable's entry\.

The listener keeps an idle connection for 290 seconds before it closes it, and its headers timeout stands five seconds above that\. So where the ingress in front of the plane pools an idle connection for less, the listener never closes one the ingress still pools\.

MAPI\-16: The synthetic estate is six grant\-marked rows of the enumeration under `grant: synthetic_estate` \(MAPI\-09\): a seed and a purge, both reversible, and four observe reads, of a purge, of a sign\-in code, of setup mail, and of an account's state\. Its grant is a third grant beside the destructive class and `super_admin`, minted on MAPI\-14's terms, the grant the compat harness's and the live tests' tokens carry\. The estate is the company's own act on the company's own test fixtures, naming no customer account \(the synthetic account kind the accounts and billing PRD states; API\-L0\-12\)\.

The grant bounds the token that carries it, at the platform's two seams\. So does `publication`, the fourth grant, which marks the two publish rows \(MAPI\-09\)\. It is minted on MAPI\-14's terms, the one grant the publisher's token carries \(CRD\-01\)\. So does `feedback_queue`, the fifth, which marks no row and is the one grant `read_feedback` and `settle_feedback` name under `admits` \(MAPI\-18\), the one grant the feedback queue's triage token carries\.

So does `issues`, the sixth, a space grant any session of the account gives for one space it holds \(MAPI\-14\), which marks no row and is admitted on `list_tokens` and `relay_issue_act`\. So does `synthetic_seed_purge`, the seventh, a staff grant minted on MAPI\-14's terms, which marks no row and is named under `admits` on three of the estate's rows\. With `tzmesh` and `tztrack`, the two paragraphs after this one, and `device_sign_in`, the session bound stated after them, the eight are the bounding grants\.

`tzmesh`, the eighth grant, is a product grant any session of an account holding the `tzmesh` profile gives \(MAPI\-14\)\. It marks no row and is named under `admits` on `list_tokens` and `submit_feedback`\. Its reach into its product's own service is the signed form MAPI\-03 states\. The `tzmesh` service verifies each token by signature with no call to the plane per token it admits; it reads the key set the plane publishes and the plane's revocation list from the plane on its own schedule, the list once a minute \(MCP\-02\)\. What the service admits the token to is the `tzmesh` member's, stated in its own requirements\. A token it bounds is admitted to `list_tokens`, to `submit_feedback`, where it files a report, and to the anonymous rows\. It is refused every other row 403 `tzmesh_bounded`, the refusal's members the same\.

`tztrack`, the ninth grant, is a product grant any session of an account holding the `tztrack` profile gives \(MAPI\-14\), and the tzTrack exchange issues \(MCP\-02\)\. It marks no row and is named under `admits` on `list_tokens`, `list_issue_spaces`, `submit_feedback`, `share_space`, `set_ai_passes`, `list_space_members`, `create_space`, `delete_space`, and `rename_space`\. Its reach into its product's own service is the signed form MAPI\-03 states, which that service verifies as the `tzmesh` service does, reading the `tztrack` key set and revocation list \(MCP\-02; system:XIT\-24\)\. What it admits the token to is the `tztrack` package's to state\.

A token it bounds is admitted to the anonymous rows and to the rows of those nine it reaches: all nine for a token a sign\-in's exchange issued, and `list_tokens`, `list_issue_spaces` and `submit_feedback` for a token `mint_token` minted\. It is refused every other row 403 `tztrack_bounded`, the refusal's members the same, its `admitted` naming the rows that token reaches\.

`share_space`, `set_ai_passes`, `list_space_members`, `create_space`, `delete_space`, and `rename_space` admit a token a sign\-in's exchange issued, a person present, the device grant's among them\. They refuse a token `mint_token` minted 403 `tztrack_bounded`, the refusal naming the three rows that token reaches\. `delete_space`, the one destructive row of the nine, reads that refusal in its description, after the class gate, so a minted token holding no class is refused `destructive_class_required` first \(MAPI\-12\)\. A test over the enumeration holds that the destructive rows a `tztrack` token's bound admits are `delete_space` alone, and that each is among the six, so the class a sign\-in's token takes at its minting \(MAPI\-14\) reaches no other row\.

`device_sign_in`, the tenth grant, bounds no minted token\. It bounds the builder realm's device\-grant session, issued for the plane's own resource or a customer MCP address's \(MCP\-02; MAPI\-14\)\. The bound stays on the session's binding through renewal \(MCP\-10\)\. It marks no row\. The rows whose `admits` names it are `start`, `read_account`, `read_context`, `read_documentation`, `read_approval_status`, `submit_feedback`, `create_space`, `share_space`, `set_ai_passes`, `list_space_members`, `delete_space`, `rename_space`, and `list_issue_spaces`\. A plane row joins that list only by a revision of this paragraph naming it, with its `admits` mark\. A test holds the marked rows to this list\.

A session it bounds is admitted to those rows, to the anonymous rows, and to the forwarded rows of the products its account holds \(MCP\-14\)\. It is refused every other unmarked row 403 `device_sign_in_bounded`, the refusal's members the same\. Among those rows are `mint_token`, `export_account`, `link_identity`, `delete_account`, `sign_out_everywhere`, the token and connection rows, and every row marked `product: cloud`\. The session holds no `super_admin`, so every grant\-marked row refuses it 403 `grant_required` naming the row's grant, an operator's account included \(MAPI\-09; MAPI\-14's order\)\. On the data planes it reaches no declaration, as the paragraph on the data planes states\.

A minted token whose grants hold one of them and not `super_admin` is bounded by it exactly as this statement states for `synthetic_estate`\. It is admitted the rows its grant marks, the rows the enumeration marks `admits` with its grant's name, and the rows marked `access: anonymous`\. It is refused every other row under the grant's own name, `synthetic_seed_purge_bounded` for the hosted trial's, `publication_bounded` for the publisher's, `feedback_queue_bounded` for the triage token's, and `issues_bounded` for a token the space grant bounds, the refusal's members the same\.

A mint gives a token that takes no `super_admin` at most one of the bounding grants, and a request naming two is refused 400 `invalid_request` with nothing minted \(MAPI\-14\)\. So no token carries two bounds, and a session carries at most the device grant's\. A stored row that did would be bounded by the first of them in the order the predicate reads them, `synthetic_seed_purge`, then `synthetic_estate`, then `publication`, then `feedback_queue`, then `issues`, then `tzmesh`, then `tztrack`, then `device_sign_in`, its reach the narrower for it\. `synthetic_seed_purge` stands first because its three rows are among the estate's, so a row naming both meets the three alone\. No row of the enumeration marks `admits` with `publication`, so the publisher's token reaches its two rows and the anonymous rows and no other, `list_tokens` and `read_account` among the refused\.

The triage token reaches `settle_feedback`, `read_feedback` in every form, and the anonymous rows and no other, `submit_feedback`, `list_tokens`, and `read_account` among the refused\. So a report it reads can turn it to no filing and to no act beyond the queue\. A token the space grant bounds reaches `relay_issue_act` for the one space its grant names, `list_tokens`, and the anonymous rows and no other, the space and the level judged at the relay's handler \(the issue service PRD's relay row\)\. An act above its level is refused `issues_level_refused` naming the level and the acts it admits, so a token a teammate's clone or a build step holds reaches one space of its account at one level and nothing else\.

It is admitted to the rows the enumeration marks `admits: ["synthetic_estate"]`, two rows, ten rows in all with the eight above\. One is `list_tokens`, the observe read under which every consumer of such a token finds its own row's expiry\. The other is `submit_feedback`, the filing of a report into the company's own space of the issue service \(MAPI\-18\)\. That filing names no customer account and reaches no customer's data, the ground the operator signal's row stands on \(MAPI\-17\), so a company harness files its findings under the token it already holds\. Such a filing may cite the reference of a call an account of a batch that credential seeded made, the stamp and the daily pass's join reading under that account \(MAPI\-18; PLD\-L0\-67\)\.

The token is also admitted to the rows marked `access: anonymous` \(MAPI\-11\), which lie outside the bound and answer a bounded token as they answer every connection, the credential\-filtered view where MAPI\-11 gives one\. Every other row refuses it 403 `synthetic_estate_bounded`, `read_documentation` among them, which carries no anonymous mark\. The exception is where a refusal that answers every credential ahead of the bound answers it first\. The approval row's `browser_session_required` \(MAPI\-05\), a page\-only row's refusal of an `Authorization` header \(MAPI\-03\), and `not_yet_provisioned` on a row whose implementation has not arrived \(MAPI\-10\) are among those refusals\. The bound's refusal carries a `grant` member naming the bounding grant\. Its `admitted` member names the rows the grant and the `admits` mark admit, the anonymous rows outside the bound and named in the row's clause\.

Under that grant a repeat is answered only where the batch or the purge is the caller's own\. A seed repeating another credential's `request_id` is refused 400 `invalid_request`, and a purge doing so 409 `account_outside_batches`\. Under `synthetic_estate` the read and both repeats answer every caller, the harness's tokens sharing one operator account\. The token's own row stands in its owner's `list_tokens` answer, which the token itself does not read\.

The `admits` mark is the enumeration's own member on MAPI\-11's pattern, this statement's to own\. The bound's gate runs after the grant gate, under which a grant\-marked row that does not admit the token keeps `grant_required`, and before the destructive\-class gate \(MAPI\-14\)\. The grant gate admits a token on a grant\-marked row where it holds the row's grant or `super_admin`, or where the row's `admits` mark names the grant that bounds it \(MAPI\-09\)\. One exported predicate over the enumeration's three marks, the grant, the `admits` mark, and the access mark, serves the gate, the MCP listing \(MCP\-08\), and the `admitted` member, no list kept beside the enumeration \(MAPI\-11\)\. One exported predicate likewise decides the grant gate and the listing's grant rule, reading the token's bound and never another grant it holds\.

On the data planes the bounded credential reaches no declaration of the account\. Object storage refuses it 403 `area_scope_refused` on a route of a declared area and at a minting request the route would otherwise admit\. The egress gateway refuses it 403 `upstream_scope_refused` on a call naming a declared upstream\. The refusals that answer ahead of each surface's reach rule answer it as they answer any account\-wide credential\. With those and the two scope refusals, neither surface serves it\. The two refusals carry the bodies those surfaces' owning statements state \(OST\-L0\-03; EGW\-L0\-08\)\. So every consumer of the estate presents the seeded account's own token on the data planes and never the grant\-carrying one\. The same two refusals answer the hosted trial's token, the publisher's token, the triage token, a token the space grant bounds, whose acts are management actions alone, and the session the device grant bounds \(MCP\-02\)\.

A token minted with a bounding grant and `super_admin` is `super_admin`'s and is bounded by nothing \(MAPI\-09\)\. And `all: true` on the purge, the purge of a batch another credential seeded, and the code read and the state read for any synthetic account are `super_admin`'s \(MAPI\-09\)\.

The seed takes `count` \(1 to 100\), an optional `label_prefix` \(`synthetic-` by default\), the required `token_expires_in_days` \(1 to 3650\), an optional `request_id`, refused `invalid_request` where it opens the reserved `first-sign-in:` \(below\), an optional `sign_in`, and an optional `products`\. The last, on the invitation member's vocabulary, is read for the invite group alone, a `tzteam` among it joining the group, and the seed writes no product row \(ACB\-L0\-79; ACB\-L0\-77; ACB\-L0\-76\)\. The seed creates `count` synthetic accounts and mints one account\-scoped token per account through `mint_token`'s own code path: no grant unless `token_grant` names one, the given expiry, the label `<label_prefix><n>`\. It answers each token value exactly once, as `mint_token`'s wire exchange does \(API\-L0\-05; MAPI\-23\)\. It writes one action record per created account and per minted token naming the calling credential, the operator's session or the harness's token \(MAPI\-06\)\. The tokens are ordinary minted tokens, shown by `list_tokens` and ended by `revoke_token`\.

`tools_plan`, an optional member, is one of `free`, `tools`, and `tools_plus`, and `app_hosting`, an optional member, is a boolean, each refused `invalid_request` otherwise\. A seed naming either writes each created account's `tztrack_subscriptions` row, state `active` and no provider identifier, and its feed row in that row's transaction \(ACB\-L0\-92\), so a proof of a per\-person limit holds a fixture on a plan before collection is built\. A value left out reads as its column's default, and a seed naming neither writes no row\. A repeat creates nothing and writes no plan\. The purge removes the row with the account\.

`token_grant`, an optional member, is `tztrack` alone; any other value is refused 400 `invalid_request`\. With it, each account's one token is minted through `mint_token`'s own mint with the `tztrack` grant, level `admin`, and the seed's label\. Its value is signed under the product's realm \(MAPI\-03; MAPI\-14\)\. It requires `token_expires_in_days` 1, `sign_in` absent or false, no `access_link` member, and an estate naming a tzTrack origin\. A failed condition refuses 400 `invalid_request` before any account is created\. Under `synthetic_seed_purge`, the member instead refuses 403 `synthetic_posture_refuses`, naming `token_grant` as the bound and that grant\. Without the member, the seed keeps its token with no grant\.

`access_link`, an optional member, is admitted under `super_admin` alone and refused 403 `grant_required` naming `super_admin` otherwise\. It requires `count` 1, no `sign_in`, no `tools_plan`, and no `app_hosting`, refused `invalid_request` otherwise, since the account is a real person's\. It takes `sign_ins`, 1 to 50, 15 where absent\. The wire answer carries the link once beside the token, and a repeat answers none \(ACS\-L0\-22\)\. Over the MCP surface a seed naming `access_link` is refused `invalid_request`, naming the wire route, and creates nothing\.

Every seed, one without `request_id` too, records a batch under a server\-minted identity answered as `batch`\. The batch row carries the expiry instant fixed at seeding, `swept_at`, and the nullable `seeding_credential`, a minted token's identity and null for a session seed\. The expiry instant is the posture's account lifetime from the seeding instant, so a posture change moves new seeds alone and a stress expiry never turns twenty\-one days into three mid\-test\. With `sign_in: true` the seed binds, per account, the second identity ACB\-L0\-79 states — the `email` identity at the reserved fixture domain `synthetic.turnzero.ai` — in the seed's own transaction beside the `synthetic` identity, and the answer carries, per account, `email`\.

This paragraph qualifies the batch's expiry fixed at seeding and the account lifetime cell: an access\-link batch's expiry is ACB\-L0\-87's, never the posture's lifetime\.

A repeat carrying the same `request_id` from the same operator's account answers the same batch's identity, account ids, labels, and, where the seed carried `sign_in: true`, each account's `email`, without token values\. The repeat creates nothing, so a retried call never double\-creates, and a batch whose values were lost is purged and seeded again\.

The purge takes `accounts` \(account ids\) or `all: true`, an optional `request_id`, and an optional `drop_metering`\. Where any named id is a standing account that is not synthetic, the purge refuses the whole request 409 `account_not_synthetic` and deletes nothing\. Under either synthetic grant alone it admits an account only where its batch's `seeding_credential` equals the caller's own identity, refusing the whole request 409 `account_outside_batches` otherwise\. That refusal names the grant that bounds the caller, and so does the refusal of `all: true` where the posture admits `all: true`\. Under `synthetic_seed_purge` the scoping is read first, so an id outside the caller's batches answers `account_outside_batches` whatever account it names\. So an account no batch names, a batch a session seeded, and a batch another credential seeded are purgeable under `super_admin` alone\.

The purge deletes the account's access link\.

A second purge naming an account a running purge already holds joins that purge\. The account is walked once and its state read from either purge, the joining purge's own state covering the accounts it walked itself\. A unique index over the live account rows holds the join across replicas\. A joining purge that asked the metering drop raises the walking purge's own `drop_metering`, which its runner reads again before each walk\. So the walking purge drops the metering for every account it walks after the join\. An account whose walk was in flight at the join may keep its rows until a repeat purge under `drop_metering: true`\.

An account already gone completes with zero removals, so a repeat purge of purged ids is a no\-op\. A walk that stops at a failing member ends the account `failed` with the error and the receipts written before the failing member \(the estate receipts, the application receipts, and the failing member's name\)\. A repeat purge naming that account runs the walk again, every member idempotent\.

A purge interrupted by a platform restart ends `failed` with the outcome `interrupted` under the rule deploys follow, and a repeat converges\. Under that rule the shutdown handler finishes the runs the process holds\. An account whose walk was in flight at the interruption still ends `completed` with its receipts where the walk returns\. A sweep on the stale\-deploying sweep's cadence finishes a running purge whose heartbeat is older than the deploy's stale bound\. A store failure of the runner's own ends the purge `failed` with the outcome `runner_failed`\. A repeat carrying the same `request_id` answers the same purge\.

With `drop_metering: true` the purge also removes each account's meter rows, so the test leaves no trace in platform usage\. The meter rows are its usage events, its storage and egress call rows, and its applications' traffic, verification rollup, and database sample rows\. The action records stand, because MAPI\-06 makes the operational record append\-only\. The realm event log's rows stand, because no action removes them \(ACS\-L0\-02\)\.

The estate runs under a posture, one value of the control plane's setting `SYNTHETIC_ESTATE`: `off`, `compat`, or `stress:<YYYY-MM-DD>`\. The date is the stress posture's expiry, after which new seeds take `compat`'s cells while the purge and every other ceiling read the value's posture\. `on` is an alias of `compat`, and any other value reads as `off`\.

The ceilings are constants this statement states and the code holds, never settings rows, so no runtime surface raises them\. They are shared: a seed counts against them whichever of the two synthetic grants its credential holds\. Each is stated as its `off`, `compat`, and `stress` cells with the refusal it names\. Standing synthetic accounts are 0, 25, and 6,000, the seed refusing 409 `synthetic_ceiling_reached`\. Standing synthetic applications, and those on a paid plan, are 0 and 0, 50 and 10, and 12,000 and 12,000\. They are refused 409 `synthetic_ceiling_reached` at `create_application` and, under `usage`, at `set_app_size` for a synthetic\-owned application\. Accounts one seed call creates are none, 25, and 100, the seed refusing 403 `synthetic_posture_refuses`\. Token expiry the seed admits, in days, is none, 3, and 30, the seed refusing 403 `synthetic_posture_refuses`\.

Account lifetime, in days, fixed at seeding and the sweep purging at its end, is none, 3, and 21, with no refusal, the catch\-all's bound under `off` being `compat`'s\. Accounts seeded per operator account per UTC day are 0, 1,000, and 6,000, the seed refusing 409 `synthetic_ceiling_reached`\. `all: true` on the purge is refused, refused, and admitted to `super_admin` alone, the refusal 403 `synthetic_posture_refuses`, so a purge under `compat` names the accounts it removes\. The posture's expiry is none, none, and the date in the value\. The seed reads its two ceilings by one call's count under no lock\. So seeds admitted concurrently may together pass a ceiling by at most their counts, corrected at the next seed's read and by the lifetime sweep\.

The `synthetic_seed_purge` grant has a standing ceiling of its own, a constant the code holds beside the cells\. Under it a seed is refused 409 `synthetic_ceiling_reached`, naming the ceiling `standing_accounts_per_credential`, once sixteen standing synthetic accounts are ones the calling credential seeded\. The count reads the batches that credential seeded against the standing synthetic accounts, ahead of the posture's own ceiling\. An account whose purge is still in progress counts until its walk removes it, so the count errs closed\. It is read under no lock, so two seeds admitted at once may both pass it\. A token minted to replace another starts at zero while the lifetime sweep purges the old one's batches\. So a disclosed copy holds at most sixteen of the standing accounts\. A `synthetic_estate` token and a `super_admin` credential meet no such ceiling\.

An account seeded under that grant holds one application at `shared-0.5gb`, the size stored as the Free plan\. A creation at `shared-1gb`, or a move to that size through `set_app_size` under `usage`, is refused 409 `synthetic_ceiling_reached` naming `paid_applications_per_account`, under every posture\. Under `plans`, a second application meets the Free plan's own limit\. Under `usage`, a second creation refuses 409 `synthetic_ceiling_reached`, naming `applications_per_account`, under every posture\. The account is told by its batch's seeding credential, a token the grant bounds, whether or not that token still stands\. So a disclosed copy's accounts take none of the estate's paid\-plan places\.

The two writes, the seed and the purge, are admitted only while the posture is not `off`\. While it is `off` they refuse 403 `synthetic_estate_disabled` before any other check\. The dispatcher's switch gate runs ahead of the credential\-kind, scope, grant, bound, and destructive\-class gates, so a customer's session meets this refusal and not `grant_required`\. Their rows, marked `switch: synthetic_estate` in the enumeration, are listed as tools while the posture is not `off` and unlisted while it is\. They are listed only to a connection whose credential holds `synthetic_estate` or `super_admin` or is bounded by `synthetic_seed_purge`, both rules MCP\-08's\. The listing is derived from the enumeration's own marks, the credential, and the setting, and no list is kept beside it \(MAPI\-11\)\.

The lifetime sweep is the platform's own locked pass in the management service, every ten minutes on the stale\-deploying sweep's cadence, one replica per tick\. It runs outside the switch gate, so it meets no posture gate\. It starts each expired batch's first purge once, by a compare\-and\-set of `swept_at` from null in the statement that starts the purge, so a second tick starts nothing\. That purge carries `drop_metering: true`, the batch's own requesting account, and a `request_id` of null, never a batch identity\. A batch identity would let an operator's earlier purge under the same key answer the sweep's as a repeat and start nothing\. The purge also carries an action record whose actor is the requesting account under the credential kind `platform_sweep`, the platform's own act, which holds no grant and no destructive class \(MAPI\-06; MAPI\-12\)\.

A batch whose seeding credential reads revoked or expired is swept at the next tick, so no batch outlives its credential\. A batch whose credential is null is swept at its expiry alone\.

The pass's catch\-all returns what a failed walk left\. Each tick, a builder\-realm user row carrying the `synthetic` flag is due where it is older than the posture's lifetime by its own creation instant \(`compat`'s lifetime under `off`\)\. It is also due where a swept batch whose expiry is past names it\. The sweep starts one purge per requesting account for the due rows under a fresh per\-tick `request_id`, never a batch identity\. The requesting account is the batch's own where a swept batch names the row\. Otherwise it is the account opened by the first entry, in the setting's order, of the control plane's operator set `SUPER_ADMIN_IDENTITIES` whose identity has opened one \(MAPI\-09\)\. So where no entry has, the rows a swept batch names are still purged under the batch's own account, while the rows no batch names are skipped with a marker line once per pass\.

A row is excluded while an unswept batch names it or while a purge account row in `pending` or `running` holds it\. So a walking account is never walked twice, and one tick's purge is not restarted at the next\. A tick that swept a batch or started a catch\-all purge writes one info line to the control\-plane stream naming the batches it swept, the purges it started, and the count of the catch\-all's accounts\. A tick that did neither writes none\. The console marker line below is apart from that line\.

The codes held under an account are its own sign\-in's on the builder realm, and those of fixture end users in the realms of applications it owns\. ACS\-L0\-12 holds a code under an account in an application's realm only where the realm's owning account is synthetic and the address is at the fixture domain\. So the read answers such a code by the owning account and the start's binding hash, and answers nothing of a person's sign\-in\. It answers no code for an account whose record is gone, whatever row a start left standing under it until the sweep's delete\.

This paragraph states that a test end user's code is held under its realm and user, never under an account or an address, so this read answers none of it \(ACS\-L0\-20\)\.

The management service writes a console\-log line carrying a marker constant when a seed is refused at a ceiling, when the standing accounts pass half the posture's ceiling, and when the sweep starts a purge over an account that still stands\. Such a purge is every catch\-all purge, and a batch's purge where an account the batch names outlived its seeder's own purge\. The service writes no line for a batch's purge whose accounts are all gone, which completes with zero removals and is started all the same for the metering it drops\. It writes none there because the ordinary batch's seeder purged it long before its expiry, and a line there would mail the operator at every seed's expiry\. The line's count is the accounts still standing\.

The fifteen refusal names this statement owns are rows of `schemas/wire_errors.json` \(MAPI\-15\)\. `synthetic_estate_bounded` \(403\) answers a token the grant bounds on a row outside the bound\. `synthetic_seed_purge_bounded` \(403\) is the same answer for a token the `synthetic_seed_purge` grant bounds, on a row no grant marks\. `publication_bounded` \(403\) is the same answer for a token the `publication` grant bounds, `feedback_queue_bounded` \(403\) for a token the `feedback_queue` grant bounds, and `issues_bounded` \(403\) for a token the `issues` grant bounds\. `tzmesh_bounded` \(403\) is the same answer for a token the `tzmesh` grant bounds, and `tztrack_bounded` \(403\) for a token the `tztrack` grant bounds\. `device_sign_in_bounded` \(403\) is the same answer for the session the device grant bounds \(MCP\-02\)\. `issues_level_refused` \(403\) answers a relayed act the level of the token's `issues` grant does not admit, naming the level and the acts it admits\.

`synthetic_estate_disabled` \(403\) answers every wire write of the estate while the posture reads `off`\. `synthetic_posture_refuses` \(403\) answers an act the standing posture does not admit, and a seed past the `synthetic_seed_purge` grant's own bounds\. `synthetic_ceiling_reached` \(409\) answers a count the posture bounds, and the `synthetic_seed_purge` grant's own two ceilings\. `account_not_synthetic` \(409\) covers the code read and the state read beside the purge, the two reads under `super_admin` alone\. `account_outside_batches` \(409\) answers the purge, the code read, and the state read under a synthetic grant naming an account outside the caller's batches\. The two reads read the reach first, as the purge does under `synthetic_seed_purge`\. Under `synthetic_seed_purge` it also answers a purge repeating another credential's `request_id`\.

A test in the platform's suite holds the seed with its batch and its `sign_in` option, the purge with its scoping under the narrow grant and its join, the reads, and the posture with its grammar and its alias\. It holds each ceiling at its refusal, the grant, and the bound of each bounding grant at the dispatcher's gate, in the listing, and on the two data planes\. It holds the `synthetic_seed_purge` grant's three rows, its bounds on a seed, its two ceilings, and its scoping of the purge, the read, and both repeats\. It holds the sweep — its once\-per\-batch mark, its null `request_id`, its credential rule, and its catch\-all — the code read, the usage member, the alert line, and the interruption\. It holds an application realm's code read, the purge's delete of held codes, and no code for a gone account\.

The default `setup` answer carries no `kind`\. Where ACS\-L0\-23's published welcome file passes, it composes that file's subject and text, with `file` naming it and `source` `site`\. Otherwise it uses the plane's built\-in text directly, with `file` null and `source` `built_in` \(ACS\-L0\-23\)\. `refused` is null when the welcome file is absent, and gives its check's reason when a present file is refused\. The account's sign\-up link chooses the product word in the welcome address, never a file\. It answers `account`, nullable `sign_up_link` and `file`, `source` as `site` or `built_in`, nullable `refused`, `subject`, `text`, `html` and ordered HTTPS `links`\. The common `contract_version`, `reference` and `detail` stand beside them\.

A `reminder` or `connected` answer adds that `kind`\. The reminder composes the welcome file's text under its `reminder_subject`; it has no usable words where that file is absent, refused or lacks that subject\. The connected email reads its one published file\. Neither has a fallback or built\-in words\.

With usable words, `source` is `site`\. With none, `source` is `none`, `file` is null, `subject`, `text` and `html` are empty, and `links` is empty\. `refused` gives the file's refusal, or null\. The welcome address receives the sign\-up product as ACS\-L0\-26 states, in the synthetic read as in a send\. The read works on either estate with the posture `off`; links point to production, and each read is recorded\.

Under `synthetic_estate`, it reaches the batches the caller's own credential seeded and every first\-sign\-in batch\. An account outside that reach is refused 409 `account_outside_batches`, the reach read first\. Under `super_admin`, any synthetic account is admitted and an existing non\-synthetic account is refused 409 `account_not_synthetic`\. Under `super_admin`, an unknown id is refused 404 `not_found`\. The required `account` is the only account selector; `kind` chooses the email\. No address or binding is accepted\.

A first sign\-in at the fixture domain \(ACB\-L0\-79\) writes one batch at its confirmation\. Its requesting account is the operator set's first opened account \(MAPI\-09\), its `seeding_credential` null, and its `request_id` `first-sign-in:<lowercased address>:<account id>`\. Its expiry is the posture's lifetime from the creation instant, so the lifetime sweep takes an abandoned account by its batch as it takes any expired batch, and the catch\-all reads nothing new\. A confirmation whose batch write fails removes the account it created, so no account stands at the fixture domain that no batch names\. A label re\-used after its first account's purge writes a second batch, the first untouched\.

The prefix `first-sign-in:` is reserved to that write: a seed carrying a `request_id` opening with it is refused 400 `invalid_request`, and no seed answers such a batch as a repeat\. The form is one exported constant of the estate module, read by the store and by the confirmation\.

Its reach is the code read's, the hosted trial's token refused `grant_required`\. Under `synthetic_estate` any account outside the caller's reach refuses 409 `account_outside_batches`, a standing customer account and an id no account stands for among them, the reach read ahead of the not\-synthetic check\. Under `super_admin` a standing account that is not synthetic refuses 409 `account_not_synthetic` and an id no account stands for 404 `not_found`\.

MAPI\-17: The operator signal is one grant\-marked row of the enumeration, by which a company test harness reports a run's ending, or its result, to the operator under a source name\. The row is `resource` `account`, reversible tier, marked `grant: synthetic_estate` \(MAPI\-09\)\. So the dispatcher's grant gate admits a credential holding `synthetic_estate` or `super_admin` and refuses every other credential `grant_required`, a customer's session among them, save where a refusal that answers a credential ahead of the grant gate answers it first \(MAPI\-14\)\. A token the `synthetic_estate` grant bounds is admitted to it as it is to the synthetic estate's six rows \(MAPI\-16\)\. The row is no row of the synthetic estate, which stays the six rows MAPI\-16 names: the act touches no test fixture and names no account\.

It carries no `switch` mark, so it is listed and answers whatever the `SYNTHETIC_ESTATE` posture reads\. It carries no `request_id`, each call being one report, and no `clients` member\. Its annotations are `readOnlyHint` false, `destructiveHint` false, and `openWorldHint` false, with no `idempotentHint` member, each call writing another counted line \(MCP\-11\)\. The request names `event`, `source`, and an optional `detail`\. `event` is one word of a closed vocabulary of two: `ok`, a run that ended clean, and `failed`, a run that did not end clean or a result that failed\. The words are generic, and the name of what is reported is carried in `source`, which matches `^[a-z0-9_.-]{1,64}$`\.

`detail` is a string of at most 200 characters, a null refused as any other non\-string, counted on the wire in code points as a JSON Schema `maxLength` counts them\. The MCP tool's derived validator counts UTF\-16 units and so refuses, ahead of the platform, a detail of characters outside the Basic Multilingual Plane that the wire admits\. `detail` is scrubbed before it is written: the value of a minted token, of an end user's session, and of a transfer grant, an address, and a URL are each replaced by a marker\.

A `source` or a `detail` that contains `control_plane_`, in any letter case, is refused\. It is refused because that prefix begins every marker the platform's own log lines carry and the platform's marker rules match a marker over a whole line \(PLD\-L0\-67\), so a free member naming a marker would satisfy another rule\. A `source` that contains the prefix of one of those three credential values is refused too, a `source` being written to the line as given\. A request outside these shapes answers 400 `invalid_request` with the member named in the detail, and the action adds no refusal name \(MAPI\-15\)\.

This paragraph qualifies "three credential values" in the scrub and in the refused `source` with the egress key \(SEC\-L0\-18\)\. A value of its shape in `detail` is replaced by a marker as the other three are, and a `source` that contains its prefix, `turnzero_cloud_egk_`, is refused\.

The act writes one line to the management service's standard output, a JSON object of exactly the members `marker`, `event`, `source`, `detail`, and `credential` in that order\. `marker` is the constant `control_plane_operator_signal`, and `detail` is the scrubbed text or null\. `credential` is the calling credential's identity, the value the action record names \(MAPI\-06\), a minted token's id and null for a session, which carries none, so a line a token wrote is attributable from the log store alone\. The act writes nothing of its own beyond the line, no table, no setting, and no fixture, and the dispatcher records and meters the call as it does every action's \(MAPI\-06\)\. The answer is `recorded: true` with the event and the source as given\.

The plane's workflow starter Job \(PLD\-L0\-67\) is the line's second writer\. For each failed run its GitHub App dispatched, it writes to its own console log a `failed` line of the same members in the same order\. Its `source` and `detail` are held to this statement's bounds and scrub, and its `credential` is the fixed word `workflow-starter`, since no credential calls the act there\.

The tier is reversible and not observe because the line can notify the operator\. PLD\-L0\-67 owns the two alert rules that read it, the failure rule that counts `failed` lines split by a bounded source and the heartbeat rule that reads the newest `ok` line of one named source\. This statement owns the row, the vocabulary, the bounds, the scrub, and the line\. The action has no rate bound and no refusal name of its own: a harness makes a few calls a run\. For any other holder of the grant, the platform's admission window per source address \(PLD\-L0\-67\), inside the edge's own limit on the management path, bounds the lines one address can write\.

Every holder of the grant is admitted to the row, so a disclosed copy of any token carrying it can write a line under any source name\. Among those lines are a `failed` line that notifies the operator and an `ok` line under the source the heartbeat rule reads, which keeps that rule from firing\. The line names its credential, and the credential register's rows state that reach \(CRD\-14; CRD\-17\)\.

The event words and the wire call have one home beside the platform's other operator clients\. A client script exports the two words and makes the one call, and it loads the operator client inside the call alone, so that importing the words runs nothing\. The platform's suite holds the script's words, the platform module's words, and the payload schema's `enum` equal\. It also holds the request as the client sends it, the client's refusals ahead of a call, and a refusal's status and code passed on as the wire call threw them\.

MAPI\-18: The four feedback actions, `submit_feedback`, `read_feedback`, `settle_feedback`, and the staff row that posts a check, are rows of the enumeration on the `account` resource \(API\-L0\-20; the AI tool interface's feedback scenario\)\. Beside them stand the destructive row `redact_issue_text` \(ITS\-L0\-05\) and the relay `relay_issue_act`\. The four space rows are `create_space`, `list_issue_spaces`, `delete_space` and `rename_space`, whose forms the issue service PRD's relay and provisioning rows state\. This statement states their bounds and refusals, except those of `delete_space` and `redact_issue_text`, which the issue service PRD states \(ITS\-L0\-01; ITS\-L0\-05\)\. Each is registered while the control plane's setting `ISSUE_SERVICE_ORIGIN` names the issue service, and unlisted, refusing `not_yet_provisioned`, while it is empty \(MCP\-08; MAPI\-10\)\.

On every call to the platform's own space the plane presents the space's first token, which the setting `ISSUE_SERVICE_TOKEN` carries by secret reference \(CRD\-19\), on the package's 0\.3\.0 wire, the recovered mark alone on the 0\.2\.0 wire\. On a call naming `space` it presents that space's own token, read from the plane's vault or, for a standing pair's space, from custody, and on the relay the named space's own token\. On a provisioning act and on an account space's creation it presents the provisioning credential the register's issue service provisioning credential row states\. The platform space's owning account is the setting `ISSUE_SERVICE_PLATFORM_ACCOUNT`, empty where unset \(the issue service PRD's relay row\)\.

Each of the three feedback rows takes `space` beside its own members \(the issue service PRD's actions row\); the check row takes none\. `space` names, as a lower\-case UUID, a space the acting account holds, which the call then addresses under that space's own token: a space of the account's own, an application's own space, or one space of a standing pair\. An identifier matching none refuses 404 `not_found` before any token is read; a token that does not answer refuses 503 `issue_service_unreachable`\. A request naming `application` or `environment` refuses `invalid_request` naming `space`\. The bounds below are judged before the space is resolved\.

With `space`, `read_feedback` addresses that space under its own token in every form and `settle_feedback` settles an issue of it, no grant read\. The scope gate refuses a token bounded to an application on the three rows `token_scope_refused`, the form naming no application \(API\-L0\-17\)\. The removal of `application` and `environment` from the four rows is MAPI\-02's thirty\-eighth use of its within\-version allowance, made while the platform held one builder account and six live applications, a synthetic account aside\. The paragraphs below state each row on the platform's own space\.

`submit_feedback` is reversible tier, unmarked, carrying `admits: ["synthetic_estate", "tzmesh", "tztrack", "device_sign_in"]` \(MAPI\-16\), so any bearer, any account\-scoped minted token, a token the synthetic\-estate, `tzmesh`, or `tztrack` grant bounds, and a session the `device_sign_in` grant bounds file into the platform's own space\. The request names `source`, the actor's kind, `person`, `agent`, or `system`, with `provider` and `session` on an agent's, both or neither\. It names `kind`, one of the record's eight, `bug`, `gap`, `docs`, `friction`, `question`, `task`, `praise`, and `idea`, or a word read as one of them\. Those words are `missing_capability`, `documentation_gap`, `refusal_not_understood`, `problem`, `error`, and `mistake`, which the record accepts, and the 0\.2\.0 word `usability`, which the plane files as `friction` \(the package's XIT\-01; XIT\-04\)\. It names `title`, 1 to 200 characters\. A `question` or a `task` is refused `invalid_request` from a filing the plane gives the `field` origin, ahead of any call\.

Its optional members are `text` \(or `body`\), of at most 20,000 characters, `impact` \(or `severity`, read as an impact\), and `workaround` and `proposed_resolution`, each of at most 4,000 characters\. They are also `labels`, `evidence`, `restricted`, `problem_key` \(or `key`\), and `repeat_of`; two names of one member are refused together\. `product` names the Turn Zero product a report concerns, by its technical name, is refused `invalid_request` otherwise, and is written as the label `product:<name>`\. `evidence` holds `action`, `refusal`, `reference`, and `code_site`, each 1 to 200 printable characters, the 0\.2\.0 `environment` and `version`, which the plane reads as one build the report saw, and a `context` of at most 20 short named strings\.

The request declares neither `personal` nor `excerpt`, and a call that names either is refused as MAPI\-22 states\. The `report` the answer carries holds no `personal` member\.

`files` attaches 1 to 4 images to a filing, and to no confirmation, amendment, or recovered mark\. Each item names a file `mint_upload_grant`'s put line stored: `application`, an application of the acting account; `area`, an area bound to it; `name`; and `environment`, the application's deploy target where absent\. The plane reads each file under the call's own credential, by the reach the storage route reads \(OST\-L0\-03\), through the store's streamed read\.

A file it does not find, one in the platform\-held deploy area, and one the credential does not reach are refused 404 `not_found`\. A file past the package's `attachmentBytesMax` is refused `invalid_request` by its stored size, before its bytes are read\. Each refusal names the file's place in the list and comes before any call, so nothing is filed\. The plane relays the bytes as the filing's `attachments`, the service judging their type \(the package's XIT\-05\)\. No record row, log line, or refusal carries them, and the plane serves no image on its own origin\.

The plane gives each report its origin and no filer names one \(the package's XIT\-04\)\. On the platform's space a `system` filing under a credential holding the `synthetic_estate` grant is `beta`, the AI beta run's, and every other filing `field`; on a space the request names a person's filing is `person`, an agent's `workspace`, and a program's `test`\. On a space the request names, a confirmation is relayed as given under that space's own token, and the service then judges it, and a filing's link by evidence, by the report's origin \(the package's XIT\-05\)\.

On the platform's space a filing whose `labels` names `synthetic`, the mark of the platform's own test runs, is admitted from an account whose record is marked synthetic alone \(ACB\-L0\-79\), an access\-link account excepted, since one person holds it \(ACB\-L0\-87\)\. Every other filer of this action is refused `invalid_request` naming the label, ahead of the bound and any call, a credential's grant deciding nothing\.

A `submit` relayed through `relay_issue_act` under the space's `issues` grant is a trusted session's and is not held\. The triage pass reads no issue carrying the label there \(the package's XIT\-07\), so a customer's report cannot leave triage by naming it\. The plane names the label on no filing of its own accord, and on a space the request names it is a label like any other\. This statement records a use of MAPI\-02's shape clause on `submit_feedback`'s `labels`\. The platform then held four builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

The plane writes the actor kind `person`, on every form of `submit_feedback` and on the check row, only under a credential a person holds, a builder session \(ITS\-L0\-05\)\. Under any other credential, a minted token among them, a `source` of `person` is written as `agent`, and a filing's origin follows the kind written: `workspace` on a space the request's `space` member gives, and `field` on the platform's space\. A `source` of `agent` or `system` is written as given\.

`problem_key` names the problem among the caller's own reports\. A same\-key repeat whose evidence and words equal the earlier report's answers `retried`, and one whose evidence or words differ files a second report linked to the same issue, `linked`\. A `praise` filing and a filing of another kind under one key are apart: neither is a retry or a repeat of the other, and each is answered an issue of its own side \(the package's XIT\-05\)\. With `key`, `recovered: true`, and no member of a filing, the call is the 0\.2\.0 recovered mark, relayed on the 0\.2\.0 wire, which settles the open filing the key names among the caller's own as recovered\. The service settles it only where the caller's own filing under that key opened the issue and every report on it is the caller's; otherwise it refuses the mark, and the call answers 404 `not_found` \(the package's XIT\-01\)\.

With `amends`, the number of one of the caller's own reports and never an issue's, the call is an amendment, the filer's correction or withdrawal of that report \(the package's XIT\-05\)\. Beside `source`, `space`, and the session's members it takes `withdraws`, true or false, `title`, `text` \(or `body`\), `impact` \(or `severity`\), `workaround`, and `proposed_resolution`\. Each of those it leaves out carries from the latest amendment of the amended report that withdraws nothing, or from the amended report where none stands\. A null `text`, `workaround`, or `proposed_resolution` clears that member, as an empty `text` clears the text \(the package's XIT\-05\)\. A filing refuses null on `workaround` and `proposed_resolution`, and reads a null `text` as no text\.

An amendment also accepts `kind`, `labels`, and `product` under the filing's rules\. A praise report can name only `praise`\. Other reports can name any allowed kind except `praise` \(system:XIT\-05\)\. If an amendment names `labels` or `product`, give the full set of filing labels\. `product` adds `product:<name>` to any labels supplied\. The service replaces the filing labels only on the issue the amended report opened and only while no space member has set them by hand \(system:XIT\-05\)\. At least one amendment member must be present\. Every other member refuses `invalid_request`\.

The plane relays it as one `submit` naming the actor and the origin a filing names, counted once in the bound, and makes no read of its own\. It names no `evidence_basis`, since the stamp reads `evidence`, which an amendment does not carry: the evidence stays on the amended report, which no amendment edits\.

The service admits a report the acting account filed and no other, so another account's report is answered 404 `not_found`, as a number no report carries is, and nothing is filed\. The answer is a filing's: the amendment's report, carrying `amends` and `withdraws`; the issue through the projection, or a null `issue` where it is withheld as a filing's is; the outcome `amended`; no candidates; `masked`; `personal_removed`; and `stamped` false\.

The answer carries the caller's own report, the issue through the projection without `reports`, the outcome, `filed`, `linked`, `retried`, `noted`, `confirmed`, `related`, or `amended`, up to three `candidates` it may repeat, `masked`, the credential forms the service's scanner hid, and `stamped`\. It carries `personal_removed` too, the personal forms the scanner removed from the filing in the order it applies them, as the service answers it, and empty where none was removed \(the package's XIT\-05\)\.

On the platform's own space, `submit_feedback`'s and `read_feedback`'s answers carry the projection with `requirements` null, since it holds the statement identifiers of an issue closed as designed \(MCP\-05\)\. They also carry `note_to_reporters` null where the note carries a statement or decision identifier, read by its form as the MCP\-05 census reads one, so a token of that form in a plain note withholds it too\. A filer there reads the close's fixed sentence and a note's plain reason, and no statement behind either\. A landing's note, in its one fixed form, carries none and is answered as the package's XIT\-08 gives it\. A team's own space and the check row's answer carry both members whole \(the package's XIT\-08\)\.

The plane answers each candidate as the service answers it, except as the next paragraph states\. Its title is the issue's or null by the package's rule, so a candidate carries no title that a report of an origin other than `workspace` or `platform` gave \(the package's XIT\-05\)\. `repeat_of` beside a filing confirms a candidate after the filing, and `report` with `repeat_of` and no member of a filing confirms one alone, the contract's `follow` \(the package's XIT\-05\); a filing that confirms counts two calls in the bound\.

On the platform's own space, a credential that does not read the queue is answered no candidates: a reporter sees its own reports alone, and the platform team links a duplicate at triage\. Such a credential may still name in `repeat_of` an issue that holds one of its own reports, judged as the next paragraph states\.

On the platform's own space, for a credential that does not read the queue, the plane reads the issue a confirmation names before it relays the `follow`, the read counted once in the read bound\. The read names the caller's account as the reading actor, so the service answers its projection, an issue a merge closed as a duplicate answered as its master \(the package's XIT\-08\)\. The `follow` then names the issue the read answered, and so do the answer's `repeat_of` and issue\. A confirmation that names a restricted issue, or an issue holding no report of the caller's account, is answered 404 `not_found` exactly as one that names no issue is, and links nothing\. So is one whose master is restricted or holds no report of the caller's account, the merge chain, its bound, and a duplicate naming no master being the service's projection's to decide\.

A credential holding `feedback_queue` or `super_admin`, which reads the queue, has its confirmation relayed as given, with no read\. The service then judges it: it confirms a report of the origin `field` or `beta` onto no restricted issue under any token, and refuses the `follow` as one naming no issue \(the package's XIT\-05\)\. So that credential is answered 404 `not_found` too, and nothing is linked\. The plane's reading stands as a second check: it judges the record's own `restricted` member, and answers a record that carries none as a restricted one\.

On that space, a filing whose answered issue is restricted, or carries no `restricted` member, answers a credential that does not read the queue its own report, the outcome as given, and a null `issue`, no member naming the issue, whatever linked the report\. A `repeat_of` naming that issue is answered as one naming no issue is\. The report stays filed\.

The service itself links a report of the origin `field` or `beta` to no restricted issue by its evidence, so such a filing is answered the unrestricted issue it joined\. One whose evidence matched a restricted issue and nothing else opens its own issue restricted, and answers that credential the null `issue` \(the package's XIT\-05\)\. A filing that asks the mark itself, and a repeat under the filer's own key onto a restricted issue, answer that credential the null `issue`\. The plane's withholding stands as a second check, judged from the record's own mark\.

A confirmation across the `praise` kind links nothing: the service answers `related` with the report's own issue, and relates the two issues as the package states \(XIT\-05\)\. The plane answers that word and that issue through the projection, or a null `issue` where it withholds the issue as a filing's answer is withheld, and no member names the relation\. A filing beside `repeat_of` whose confirmation is answered `related` keeps its own issue, carries no `repeat_of` member, and reads `outcome` `related`\. On a space the request names, the owner is answered the same word and the issue through the projection\.

On the platform's space, for a credential that does not read the queue, the plane relays the recovered mark only where the filer's filing under that key opened the issue it lands on, and that issue is unrestricted and holds that filer's reports alone\. Otherwise the plane refuses it 404 `not_found` before any write\. A key under which the filer holds no report is refused by the plane as the service refuses it, relaying nothing, and a read the service could not answer is refused as any unanswered call is\. A relayed mark answers the issue's `id`, `status`, and `disposition` alone, and the plane's two reads ahead of the mark count in the read bound\.

Where the evidence quotes a reference, the plane reads the newest row of the action record carrying it under the acting account within the twenty\-five days before the filing, once more after the record's one\-second flush where the first read finds none \(MAPI\-06\)\. Under a credential holding the `synthetic_estate` grant it reads the accounts of the batches that credential seeded too, the synthetic\-batch clause \(MAPI\-16\)\.

Where a row joins, the evidence carries the row's `action` and the context the filer gave\. Where the row's outcome is a refusal, the evidence carries that `refusal` and the row's `code_site` too and is stamped on either of two grounds\. The filing's kind, an alias read as its record kind, is `bug`; or its impact is `blocked`, its kind is neither `praise` nor `idea`, and the action is one of the target space's `critical_actions`\. The latter ground reads the target space's configuration once; a failed read admits no critical action, so only a `bug` stamps\.

The stamped request goes to the service with `evidence_basis: stamped`\. Where the call completed or waits for approval, the request keeps the filer's refusal, if any, as claimed evidence, with no basis and no code site\. A filing citing a refused call that meets neither ground names the refusal alone and stands `claimed`\. The action record names no refusal for an answered call\. At filing, the service neither fingerprints nor joins a claimed report by a refusal with no code site\. A stamped report joins by its action, refusal, and component, subject to the package's rule keeping praise apart from every other kind \(the package's XIT\-05\)\.

The `seen_in` of a report whose row joins names the build that answered the call: its version the build's source commit, and its environment the plane's, `development` where the estate's apex opens `dev.` and `production` otherwise\. Its `release_line` is `cloud.plane` where the platform's space declares that line and null otherwise \(the package's XIT\-14\)\. Where no row joins, the filer's evidence stands `claimed` for the daily pass's join \(PLD\-L0\-67\)\. The filer's 0\.2\.0 `environment` and `version` name the one build the report saw\.

The daily pass confirms a report only where both its own kind and the kind of the issue it stands on pass the test below\.

- the kind is `bug`; or
- the report's impact is `blocked`, the kind is neither `praise` nor `idea`, and the call action is one of the platform space's `critical_actions`\.

An old report with no kind uses the issue's kind\. The pass reads the platform space's `critical_actions` once a run; a failed read admits no critical action, so both kinds must be `bug` to confirm\.

`read_feedback` is observe tier, unmarked\. With no member it answers the caller's own submissions through the projection, the caller named as the reading actor \(the package's XIT\-08\), paged by `limit`, 1 to 100 and 50 where absent, and `cursor`, selected by `state`\. The 0\.2\.0 `status` reads as a state and `unreviewed` as `new`\. With `issue`, a short identifier, it answers one of the caller's own through the projection, another account's and an unknown id both answered `not_found`\. The detail names the caller's own submission for the number only where the service answers `own`, an issue the caller reads \(the package's XIT\-08\)\. Another account's issue, a restricted one, and an absent number name none and read alike\. With `query`, 1 to 200 printable characters, it searches the caller's own submissions, selected by `state`, `kind`, and `component`\.

On the caller's own, queue, and named\-space lists and searches, `reporter_accounts` takes 1 to 20 account identifiers of 1 to 200 printable characters and selects each issue once when an eligible report's recorded account matches one of them\. Only reports in the call's existing read scope can match\. In the caller's own forms, these are the caller's projected reports\. A call naming `reporter_accounts` beside `issue` is refused `invalid_request`\.

The own list, search, queue, and named\-space lists answer compact entries in `issues` by default\. An entry of a whole issue selects `id`, `kind`, `title`, `state`, `outcome`, `priority`, `effective_priority`, `waiting_for`, `report_count`, `updated_at`, and `restricted` from the issue the form may already answer\. Where that issue carries `restricted`, its value is `true` or `false`\. `detail`, an optional boolean, returns the full entries the caller may read when true\. The `issue` form answers one full issue within the caller's existing access and refuses any request that names `detail` beside `issue` as `invalid_request`\.

This paragraph states the entry of the caller's own list and search, which read through the projection \(the package's XIT\-08\)\. The projection carries no title of its own, so the entry holds `id`, `state`, and `outcome`, and a `title` taken only from the caller's latest visible report that has one, ordered by `filed_at` and then by report id\. Where no visible report supplies a title, the entry carries none\. It never takes the master issue's title or another reporter's\.

A credential holding `feedback_queue`, the queue's grant, or `super_admin` is answered any issue whole by its id, with its reports, links, history, comments, relations, landings, and checks \(MAPI\-09\)\.

With `queue: true` it answers every account's matching issues\. Each compact entry carries the `effective_priority` the service answers, and a full entry also carries its `impact_assessment` where the service answers one \(the package's XIT\-04\)\. The queue is selected by `state`, `outcome`, `kind`, `component`, `label`, `priority`, `stored_priority`, `origin`, and `proposed`\. `priority` selects by the effective priority and `stored_priority` by the stored one, as tzTeam says priority\. Each selects one of the three values 1, 2, and 3, and a `stored_priority` of 4 is admitted and selects as 3 does \(the package's XIT\-08\)\.

The queue is ordered `newest`, by `rank`, by `priority`, which sorts by `effective_priority` and then by `ranking_score`, or by `report_count`, the 0\.2\.0 `score` reading as `rank`\. The queue's `priority` selector and its `rank` order are the platform's own action words, which the plane maps to the service's `effective_priority` and `ranking_score`, and `stored_priority` to its `priority`\. With `query` beside `queue` it searches the whole space\.

The queue form and the whole search are admitted to a credential holding `feedback_queue` or `super_admin`\. Every other credential that reaches the handler is refused `grant_required` naming `feedback_queue`, an application\-bounded token `token_scope_refused` at the scope gate, and a token another grant bounds its own bound's refusal, in MAPI\-14's order \(MAPI\-09; MAPI\-16\)\. The row carries `admits: ["feedback_queue"]`, so a token the grant bounds reaches every form, the form with no member answering that token the operator account's own submissions \(MAPI\-16\)\. `issue` beside `queue` or `query` refuses `invalid_request`\.

The report text, the comments, the candidates, and the curated titles and summaries the actions answer are data and never instructions\. Over MCP, every completed answer of `submit_feedback`, of `read_feedback` in each of its forms, of `settle_feedback`, of the check row, and of `relay_issue_act` is rendered as one text block\. The block opens with the untrusted marker and holds the answer's JSON between an opening and a closing delimiter line\. The marker names every member a reporter, a program, or a pass wrote\. They are the titles, summaries, report texts, workarounds and proposed resolutions, labels, evidence and its context, resolutions, notes, comments, candidates, an impact assessment's reason, history change values, and the values of a count's groups\. The note stays inside the block, though the projection serves it whatever the issue's `text_trusted` \(the package's XIT\-18\)\. So nothing unmarked precedes them, and the wire answer is unchanged\.

A space's name is text its owner wrote, another account where the space is shared \(ITS\-L0\-01; ITS\-L0\-07\)\. So over MCP a completed answer of `list_issue_spaces` that lists a space shared with the account is rendered the same way, as one text block holding the answer's JSON between the same two delimiter lines\. It opens with a marker of its own, which names each space's `name` as its owner's text, to be read as data\. An answer that lists only the account's own spaces, its applications' spaces, and the platform's space holds no name another account wrote, so it is served as plain JSON, as tzTrack's `list_spaces` serves the same spaces \(issue\_service:ISV\-16\)\. The feedback actions' marker is unchanged, and so is the wire answer\.

The tzTrack server's write tools, `raise`, `wait`, `update`, `comment`, `close`, `reopen`, `claim`, and `give_back`, render a completed answer compact where it carries no text member anyone wrote \(tztrack:TRK\-L0\-03\)\. The compact answer holds the relay's envelope, the outcome, the report's and the comment's numbers, and of the issue its `id`, `kind`, `state`, `outcome`, `priority`, `due_date`, `restricted`, and `waiting_for`\. It keeps the scanner's form names, `masked` and `personal_removed`, the issue ids an update or a comment mentioned, and a settle's `related_open` rows\. Every other member is left out, the caller's own text and `claimed_by`, a free label, included\. It is rendered as its JSON alone, with no marker and no delimiter line\.

`waiting_for` is kept in its closed forms alone: null, `person`, `reporter`, `evidence`, or `person:<account>`\. A `raise` that joined an issue or whose answer lists a candidate, an answer whose issue's `waiting_for` holds any other value, `outside:<what>` among them, and every read tool keep the whole answer inside the block, since another party's text may be in it\. The wire answer of the relay is unchanged\.

`settle_feedback` is reversible tier, unmarked, carrying `admits: ["feedback_queue"]`, the queue's own grant, decided at the handler\. On the platform's own space the act is admitted to a credential holding `feedback_queue` or `super_admin` and refused every other credential `grant_required` naming `feedback_queue`; with `space` it settles an issue of a space the acting account holds with no grant read \(ITS\-L0\-03\)\. A token holding the grant and not `super_admin` is bounded by it as MAPI\-16 states: refused `feedback_queue_bounded` on every other row no earlier gate answers, a row another grant marks keeping `grant_required` \(MAPI\-14; MAPI\-16\)\. It is minted on MAPI\-14's terms from a session holding `super_admin`\. So a session that triages the queue from an AI client holds no credential a planted instruction could turn to a filing or to any act beyond the queue\.

The act names `issue` and `act`, one of `settle`, `merge`, `wait`, `reopen`, `unmerge`, and `triage`, with an optional `key`\. `settle` names an `outcome`, one of the record's eight, and, where the outcome is `duplicate`, `target`, the master\. A `resolution` of 1 to 4,000 characters is required for every outcome but `noted` and `duplicate`, and the 0\.2\.0 `disposition` reads as its outcome \(the package's XIT\-01\)\. `merge` names its `target` and closes the issue `duplicate`; `wait` names its `resolution`; `reopen` and `unmerge` take neither\. `approve` and `decline` are retired and refused `invalid_request` by name: no person approves or declines a duplicate, which the service's passes merge where they agree on stamped or confirmed evidence \(the package's XIT\-07\)\. An act the issue's state excludes refuses `invalid_request` naming the service's refusal, and the answer carries the issue as it now stands\.

`triage` names `kind`, one of the record's eight, or `component`, a component the space admits \(the package's XIT\-14\), or both, and the plane relays the package's `update` setting them \(the package's XIT\-06\)\. On a `new` issue that update opens it, so a fix can then be settled `done` \(the package's XIT\-16\)\. `triage` takes no `outcome`, `disposition`, `target`, `resolution`, or `fixed_in`\.

With the outcome `done`, `settle` may name `fixed_in`, the build that serves a fix closed by hand, `{ release_line, version, environment }` or null, and the plane passes it to the service as given \(the package's XIT\-07\)\. The service requires it on a `bug` or a `friction` holding a report of a returning origin where no landing stands\. Its absence there is refused 400 `invalid_request` naming the service's refusal, as any refusal of the act is, and a `fixed_in` that names no build is refused 404 `not_found`, as the service's not\-found refusals are\.

A `merge`, and a `settle` with the outcome `duplicate`, where exactly one of the issue and its `target` is of the kind `praise`, are refused 400 `invalid_request` naming the service's refusal `relation_refused` \(the package's XIT\-07\)\. The service judges the kind before the issue's state, so a `praise` issue closed `noted` is refused the same\.

The plane posts the check into the platform's own space naming the acting actor, so the service judges the key among that actor's checks, and answers `{ check, issue, outcome }` \(the package's XIT\-17\)\. The filing bound counts the call\.

A refusal the dispatcher answers, and an internal failure, carries after its `detail` the known\-issue line where the plane's copy of the known\-issue table names the action and the refusal \(PLD\-L0\-67\)\. The line names the issue's identifier and its trusted workaround where one stands, and, once a fix has shipped, the build that carries it and an invitation to report the refusal again naming `repeat_of` where it is still seen\. The line is read from the process's copy, loaded at boot and every minute, never from the store or the service at the call\. The dispatcher also writes on every action record row the build that answered the call and, on a refusal the handler threw, the code site, `<file>:<line>` \(MAPI\-06\)\.

The plane bounds the calls it relays in fixed windows of one minute\. Each count is taken before the call as the service counts its own, a refused call counted with the rest, and each past its figure is refused 429 `feedback_rate_limited` with a cause word of its own\. The filings and checks are at most 20 from one account and at most 100 from every account together\. The reads of `read_feedback` are counted once per service call the form makes, one for each form\. They are at most 20 from one account and at most 50 from every account together\.

Each relayed call counts once in the window of the credential that made it, at most 60 a minute for one token by its identity, a session's account where it has none \(MAPI\-06\)\. It counts once more in its target space's aggregate, at most 150 a minute for an account's own space\. A relayed call counts once more there for each call the platform may make beside it \(ITS\-L0\-05\)\. The platform's own space counts its relayed calls in the two aggregates above, a read act among the reads and every other act among the filings\. An account creates at most 5 spaces a minute through `create_space`, and renames at most 5 a minute through `rename_space`, in a window of its own\. The relay's figures and the overshoot stay at or under two\-thirds of a space's own rate, so a space's other callers keep their third\.

An account holds at most the `subscription-issue-spaces` cell of its plan as ACB\-L0\-92 reads it, during the introductory period as well as after it, an `unbilled` account reading Tools Plus \(PRC\-L0\-19; ACB\-L0\-90\)\. At its limit, a creation naming a space it does not hold is refused 403 `space_creation_ceiling` with nothing created, and a repeat naming a space it holds answers `created: false`\.

The refusal's detail names the plan, count and limit, and points to a space the account already holds or to `delete_space`, which a person approves in the browser\. While `tztrack_billing` reads 0 \(PLD\-L0\-76\), it names no plan choice\. After the end act, it also names a move to a larger plan where one exists\. An account holding more than its limit keeps every space \(ACB\-L0\-90\)\.

The `name` of `create_space` is required on every call, a repeat among them, and is 1 to 100 printable characters\. One absent, outside that, or no string is refused 400 `invalid_request` naming `name` as the request's form is judged, with nothing created and nothing counted\. Over MCP a call without it draws the argument's validation error naming `name` before the handler\. The name is written only where the creation puts the space's custody entry, so a repeat finding the entry standing writes none and answers the name that stands \(ITS\-L0\-01\)\.

This statement records a use of MAPI\-02's shape clause on `create_space`'s request member `name`, optional becoming required on every call\. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, and `schemas/mcp_surface.json` move with it\. The platform then held 4 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

The gate is read ahead of the minute's bound and this ceiling\. A creation by an account lacking the `tztrack` profile, a repeat naming a space it holds among them, is refused 403 `blueprint_required` and does not count toward the minute's 5 \(ACB\-L0\-89\)\.

`rename_space` takes `space` and `name`, each required\. The name is 1 to 100 printable characters, as the creation's is\. A missing name, one outside that, or no string is refused 400 `invalid_request` naming `name`, and a malformed `space` the same naming `space`, each with nothing written and nothing counted\. Past the minute's 5 a rename is refused 429 `feedback_rate_limited` with nothing written\. The bound is read after the form and ahead of the space's resolution, whose refusals, `space_not_owned` and `invalid_request`, ITS\-L0\-01 states\. An account lacking the `tztrack` profile is refused 403 `blueprint_required` ahead of the form \(ACB\-L0\-89\)\.

The figures are constants the code holds\. They are sized so that the relayed total, the read aggregate, and the replica overshoot together stay at or under two\-thirds of the service's space rate of 300 calls a minute, one count across the permission levels \(the package's XIT\-12\)\. The other third is headroom for the platform's own calls: the erasure, the export's pages, and the daily pass\. The export does not count against the relayed cap\. Its page reads pace themselves within that headroom and share one bound that ends every read and wait\.

The overshoot is what the management replicas together can admit past a figure before a flushed row shows every replica's hits, each replica reading a window as its last flushed row plus its own unflushed hits and flushing every second\. It is at most the plane's replica ceiling of nine times five calls a replica in one interval, a design figure the suite holds beside the sum and the template's replica count\. The service's own rate refusal answers under the same name\.

A call the service could not answer answers 503 `issue_service_unreachable` with the cause word in the detail\. The causes are the transport failing, the call passing the plane's bound of ten seconds, a fault of the service's own, the router's quota refusal on it, and a refusal of the platform's own credential\. A refusal of the platform's credential is also written once per interval to the control plane's record as a warn line naming the cause, so a lost, revoked, or unset token is read there rather than found at a customer's deletion \(CRD\-19\)\. The service's not\-found refusals answer 404 `not_found`, and every other refusal of the service, a lease's among them, answers `invalid_request` with its name in the detail\.

On the relay a refusal of the service by the act's content, the issue's state, a lease, or a record that does not stand answers `issue_refused` with the service's own status and its name in `refusal`\. The four refusal names this statement owns, `feedback_rate_limited`, `issue_service_unreachable`, `space_creation_ceiling`, and `issue_refused`, are rows of `schemas/wire_errors.json` \(MAPI\-15\), the last carrying the service's status and a `refusal` member and the rest no member beyond the base six\.

The same suite holds a space's name stored and answered, refused out of its bound, kept by a repeat and written by a retry after a lost answer, answered on a member's row, and the listing rendered under its own marker\.

This statement records a use of MAPI\-02's shape clause on `submit_feedback`'s `issue` on the platform's space\. A filing of the origin `field` or `beta` whose evidence matched a restricted issue and nothing else, once answered the unrestricted issue it opened, is answered the null `issue`, because the issue it opens is restricted \(the package's XIT\-05\)\. The platform held 1 builder account that held a live application, synthetic accounts excluded, read at the change\.

Under the usage model \(PRC\-L0\-04\), an account holds its own spaces up to the bound `subscription-issue-spaces` states for the usage form, whatever plan it chose or holds\. At that limit, `create_space` naming a space it does not hold refuses 403 `space_creation_ceiling`, with nothing created; a repeat naming one it holds still answers `created` `false`\. The detail names the count and limit, and no plan\. It directs the caller to a space the account already holds, or to `delete_space`, which a person approves in the browser\.

MAPI\-21: The application\-grain data archive is two rows of the enumeration on the `application` resource \(API\-L0\-23\)\. The fifth paragraph states `request_export` with `download: true`\. `request_export` is reversible tier and takes `application`, required, and `environment`, optional\. It answers 202 on `deploy`'s shape \(MAPI\-04\) with the export's identifier, the state `running`, the export area's name, the export's folder, `repeated`, and `next`, the `read_export` call naming the application and the export \(MAPI\-24\)\. `repeated` is true where the request answered an export already running for the application and environment\.

`read_export` is observe tier and takes `application`, required, and `export` and `environment`, optional\. With `export`, it reads that export and ignores `environment`\. Without it, it reads the newest export of the application and environment, production where none is named, whether running or ended\. The request instant orders exports, with the id breaking a tie\. If none is held, it refuses 404 `not_found`\. It answers the state, `running`, `completed`, or `failed`, the outcome of a failed export, the progress counts, and the instants\. Once the export has ended it answers the manifest, and null where the manifest file is gone\.

The outcomes are `interrupted`, `table_bound_exceeded`, `database_failed`, `files_failed`, `area_unavailable`, and `runner_failed`\. A token bounded to one application reaches the two rows for that application \(API\-L0\-17\)\. An application id no account holds refuses 404 `no_such_application`, and one another account holds refuses 403 `application_other_account` \(MAPI\-14\)\. An export the named application does not hold refuses 404 `not_found`\. A missing member, or an environment outside the platform's two, refuses 400 `invalid_request`\.

The export's row is the act's operational record: its state, its counts, and its instants, and no table or file name\. The names are the manifest's, a file of the export area, which ends with the area\. A running row whose heartbeat is older than the deploy's stale bound is ended `failed interrupted` by the read that meets it, `read_export`'s or `request_export`'s, and no timer sweeps the rows\. A pass whose application is deleted stops at its next heartbeat and ends `interrupted`, writing nothing more into the export area the teardown removed\. A test in the platform's suite holds the pass over an engine and the storage double, and the two rows over the routes\.

Before its pass writes, `request_export` removes the folders of the pair's earlier ended exports from the export area, so one folder stands per application and environment \(API\-L0\-23\)\. The replaced export's row stands, and its `read_export` answers the manifest null\. The suite's test holds the removal over the storage double\.

`request_export` with `download: true` is reversible tier and takes `application` and `export`, required, and `local_path`, optional\. It answers the export, the application, the environment, `expires_at`, and one line as `command`, `command_windows`, `command_npx`, and `command_npx_windows` \(PLD\-L0\-94\)\. The grant appears inside the four line members and in no other\. The row is admitted to the credentials `read_export` admits for the application \(OST\-L0\-08\)\. `local_path` is held to the class `deploy_command`'s `local_path` admits, and a path outside it refuses 400 `invalid_request` \(PLD\-L0\-86\)\. An export that is not completed refuses 409 `export_not_completed`, and a completed one whose manifest file is gone refuses 404 `not_found`\. Each refusal mints nothing\. A test in the platform's suite holds the mint, its refusals, and the line run against the suite's own plane\.

MAPI\-20: `restart_application` is one row of the enumeration on the `environment` resource at the reversible tier \(API\-L0\-22\)\. Its request carries `application` and `environment`, the environment one of the platform's two \(PLD\-L0\-40\)\. Its answer, status 202, carries the contract version, the application, the environment, the version the environment serves, the state `deploying`, and the environment's hostname under the current label\. For a server application, it also carries `health_path`, the recorded manifest's health path as the health gate will probe it, cut at 256 characters \(PLD\-L0\-63\)\. A serverless application's restart answer omits that member\. The action record holds the outcome `deploying` \(MAPI\-06\), and its refusals are the platform redeploy's, each a row of `schemas/wire_errors.json` \(PLD\-L0\-84; MAPI\-15\)\. On the operator's restart of another account's application \(PLD\-L0\-84\), the answer carries no `health_path`, since the path is what the tenant's manifest wrote \(ADM\-L0\-10\)\.

MAPI\-25: `check_deploy` is one row of the enumeration on the `environment` resource at the observe tier \(API\-L0\-24\)\. Its request carries `application`, and optionally `local_path`, each admitted and refused as `deploy_command` admits and refuses it\. Its answer, status 200, carries the contract version, the application, the environment a deploy would target, `refusals`, `checks`, `zip_checked`, `kind`, `credentials_missing`, `provider_credentials_missing`, `first_deploy`, `recorded_health_path`, `last_release`, `without_command`, `fallback`, `command`, `command_windows`, `command_npx`, and `command_npx_windows`, which a hosted connector's session leaves out \(PLD\-L0\-107\), `detail`, and `page`\. Each entry of `refusals` carries a refusal's name, status, and detail, the detail within a refusal's budget, and the refusal's `next` where it carries one \(MCP\-12; PLD\-L0\-107; MAPI\-24\)\. The call is refused as the deploy's start refuses the application, the manifest, the environment, and a deletion in flight, each a row of `schemas/wire_errors.json` \(MAPI\-15\)\. It is admitted under the credentials `deploy_command` admits, and under no transfer grant\.

MAPI\-26: `deploy_files` is one row of the enumeration on the `environment` resource at the reversible tier \(API\-L0\-25\)\. Its request carries `application`, and optionally `environment`, admitted and refused as `deploy`'s, `wait_seconds`, read on a call that starts the deploy alone, `file`, and `files`, naming one or both of the last two\. It optionally carries `check_only`, a boolean read as false where absent\. `file` carries `path`, `content`, and optionally `sha256` and `encoding`; each entry of `files` carries `path` with one or both of `content` and `sha256` and optionally `encoding`, or `path` with `stored` and optionally `sha256`\.

This paragraph states `encoding`\. It is `utf-8`, read where absent, for content that is the file's text, or `base64` for content that is the file's bytes in base64, such as an image, an icon, or a font\. A `base64` content is decoded before any check, so the 512 KiB, the 4 MiB, and `sha256` are held to the decoded bytes\. A JSON, JavaScript, or TypeScript file's syntax is read on its decoded text\. An `encoding` of another value, a `base64` encoding beside no content, and a content that is not strict base64 are refused 400 `invalid_request`, naming the entry or `file`\. A request's body is held to 4 MiB on the actions route and the tool surface alike, so one call carries about 3 MiB of a binary file's bytes as base64; a file kept by an earlier call is named by its `sha256`\.

This paragraph states the keep's reach\. A file kept for one of an application's environments is held for its other too\. A call that names it by `sha256` alone reads it from the environment that keeps it, its writer and its hash checked, and keeps it again under the call's own environment\. So a development environment added after production re\-sends no file production still keeps\. No file is carried while the application's stored data is over \(OST\-L0\-05\), so a hash the target lacks then reads missing\.

A call that starts nothing answers status 200 with the contract version, the application, the environment, the state `file_kept`, `awaiting_files`, or `files_checked`, and `kept`, `missing`, `left_out`, `warnings`, `content_notice`, and `detail` where it carries them\. A call that starts the deploy answers as `deploy`'s start answers, with `left_out`, `warnings`, and `content_notice` beside it, and `next` while it is still deploying\.

`content_notice` stands where text the call carried holds U\+FEFF, naming the first such file and its line; it refuses nothing\. Where the character is the file's first, the notice says that some JSON parsers reject a leading mark\. Otherwise it says that the character may be harmless in code but its context needs checking\.

Each form says how to send a literal escape safely in the call's JSON and to check the file's SHA\-256\. The notice reads the character's position, not its parsed code context\. It is at most 200 code points, with its path cut to fit, and names how many other files hold the character\.

`artifact_notice` also stands on `files_checked` and on a started deploy where the root `package.json` declares something to install and the list sends no root `package-lock.json` or `npm-shrinkwrap.json`; it refuses nothing\.

The `awaiting_files` detail, and a `deploy_files_hash_mismatch` detail for a sent `file` or content entry beside the hash received, name the common causes of a hash that misses: line endings, a trailing newline, or a byte\-order mark\. The platform never changes a file's bytes\. It is admitted under the credentials `deploy_command` admits, and under no transfer grant, and it mints and answers no grant\.

The `file_kept` and `awaiting_files` details ask for every file the deploy includes, the folder's package\-lock\.json among them where it has one, since the deploy installs from it\.

This paragraph states the call's refusals, each a row of `schemas/wire_errors.json` \(MAPI\-15\)\. A path is refused 400 `invalid_request` where it is absolute, names a drive, holds a backslash or an empty, `.`, or `..` segment, or passes 1,024 characters\. So are a path listed twice, a server's list with no root `package.json`, and a `file` whose path holds a segment the zip leaves out\. A `file` over 512 KiB of bytes, a list over 200 entries, and listed, stored, and filled files over 4 MiB in all are refused 413 `deploy_files_too_large`, its `limit` naming the cap\. A `file` whose content's SHA\-256 is not the `sha256` it names is refused 409 `deploy_files_hash_mismatch`, the per\-file form of the deploy line's `upload_hash_mismatch`\. A JSON, JavaScript, or TypeScript file that does not parse is refused 422 `deploy_files_syntax_error`\. A refusal of one file names its path, and a refused `file` is not kept\.

This paragraph extends the refusals to a list's contents\. An entry of `files` carrying `content` is refused as a `file` is: by a path segment the zip leaves out, by its 512 KiB, by a `sha256` its content does not match, and by its syntax\. Every content entry that passes its own checks is kept, though another entry of the list is refused\. A `file` the same call carries is kept first, and stays kept\.

This paragraph states a list's per\-entry refusal\. Where any content entry or stored entry is refused, the call answers the first refused entry's refusal in the list's order, its body also carrying `kept` and `refused`\. Its `kept` gives each kept entry's `path` and `sha256`, and each entry by `sha256` alone whose file the platform holds, save one the zip leaves out or one whose file the platform could not read as the refusal was built\. Its `refused` gives each refused entry's `path` and refusal name, and both follow the list's order\. A hash\-refused entry also names `received_sha256`\. After a hash, syntax, or left\-out refusal, or a stored entry's `artifact_area_mismatch` or `artifact_not_found`, the detail teaches the retry: the list sent again, each kept file by its `sha256` and each refused file corrected\. That retry detail alone also says that the files that passed, and those earlier calls kept, are held now\.

This paragraph states a stored entry\. An entry of `files` may carry `stored`, naming a storage area's `area` and a file's `name`, with no `content` or `encoding`\. The platform reads the file from the deploy target's partition of the area through `deploy`'s own read of a stored file \(PLD\-L0\-63; OST\-L0\-03\)\. It keeps the bytes under their SHA\-256 as a content entry's are, and holds them to no 512 KiB bound\. Every answer that is no refusal gives each stored entry it read by its `path`, `area`, `name`, `size`, and `sha256` under `stored`\.

This paragraph states a stored entry's total\. Each stored size is read from the file's metadata first\. Where the stored sizes and the content entries' bytes pass 4 MiB, the list is refused `deploy_files_too_large` before any stored body is read\. A stored body whose length is not the size its metadata gave is refused alike\. Nothing of a stored entry is kept, while the content entries that passed their own checks and a `file` the call carries stay kept, as the total cap leaves them\.

This paragraph states a stored entry's refusals, each falling in the list's order under the per\-entry refusal above\. An area the account has not declared, an area bound to another application, and the platform\-held deploy area are refused 403 `artifact_area_mismatch` before any byte is read\. No file of the name in the partition is refused 404 `artifact_not_found`, its detail naming the application's page on the signed\-in site, where the person uploads it\. Stored bytes a given `sha256` does not match are refused 409 `deploy_files_hash_mismatch`, and the file is not kept\. A stored entry whose path the zip leaves out is answered under `left_out` and never read\.

This paragraph states when the other refusals answer\. Every call first answers the deploy's preamble refusals\. A `file`, a list carrying contents, and a list naming a stored file are refused 429 `usage_over_quota` while the application's stored data is over \(OST\-L0\-05\)\. A call keeps its `file` and its list's contents before its list is read, so a refusal after that, the total cap or the start's own, leaves them kept\. A list call answers PLD\-L0\-86's refusals that read no artifact before `missing`, in the start's words, `library_entry_not_served` after `missing` and before the total cap, and `file_dependency_not_sent` after the total cap\.

This paragraph states the library fill\. A list call fills a library entry's copy where its root `package.json` declares `@turnzero/<name>` as a `file:` path in `dependencies`, the recorded manifest's `packages` names the entry, and the list holds no path under that path\. The fill places the entry's `package.json` and `lib/` files, read from the library \(LC\-05\), under that path as `library take` does\. The path is read with no `./` and no trailing slash, and one the zip leaves out, or one `invalid_request` would refuse, is filled with nothing\. The manifest read is the record the call's preamble admitted\. A declaration in any other section is neither filled nor refused, and an entry with no compiled modules is filled with nothing\.

This paragraph states the fill's refusal and its answer\. Where the fill's three conditions hold, a row whose version is not the one the library serves, or which names no served entry, is refused 409 `library_entry_not_served`\. The detail gives the manifest's `packages` row, the copy's path and the remedy of listing the project's own copy in `files`\. Where the library serves the entry, the detail also gives its version and two routes: take it with `library take`, or set the manifest row to that version, then `submit_manifest` and send the list again\. If the library serves no entry, the detail says so\. Filled files count toward the 4 MiB total and not toward the 200 entries\. A call that starts the deploy also carries `filled` where it filled any, naming each entry filled by its `name`, `version`, and `path`\.

This paragraph states a library copy the version would lack\. Where the root `package.json` declares `@turnzero/<name>` in `dependencies` at a `file:` path other than the folder's root, the zip carries no file at or under that path, and the fill places no copy there, the call is refused 409 `file_dependency_not_sent` and nothing starts\. Such a copy at a path the zip never carries, outside the folder or through a segment the zip leaves out, is refused alike\. Every other `file:` dependency is neither filled nor refused, since a build may bundle it\. The detail gives the remedy, then the reason with the package's name: no `packages` row names the entry, the list gives only paths the zip leaves out under that path, or the entry has no compiled modules\.

This paragraph states `check_only`\. A list call carrying it true keeps and checks its files as it would without it, builds the same zip, and runs the start's checks on it through the start's own path \(PLD\-L0\-63\)\. Those are the zip's checks, the health\-path reading, the state checks, and the refusals that read no artifact\. A refusal answers as the deploy's would, under `deploy_files`\. Where none refuses, the call answers status 200 with the contract version, the application, the environment, and the state `files_checked`\. It also carries the notices the deploy's answer would carry, `left_out`, `warnings`, `filled` where it filled any, `kept`, and `detail`\. `kept` names each file's `path` and kept `sha256`, as a refusal's `kept` does\. It writes no version row, counts no deploy of the day, builds no image, and acts on no environment\. A deploy of the same zip already in flight refuses nothing\.

This statement records a use of MAPI\-02's shape clause on `deploy_files_too_large`'s member `limit` in `schemas/wire_errors.json`: the row gains the member, naming the cap the refusal met, and `schemas/wire_error.schema.json`'s member region is generated again from the rows\. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

This statement records a use of MAPI\-02's shape clause on the members `kept` and `refused` in `schemas/wire_errors.json`, on the rows `deploy_files_syntax_error`, `deploy_files_hash_mismatch`, `deploy_files_too_large`, and `invalid_request`\. Each row gains the two members, naming a list's content entries kept and refused, and `schemas/wire_error.schema.json`'s member region is generated again from the rows\. The platform then held 1 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

This statement records a use of MAPI\-02's shape clause on `deploy_files`' response members in `schemas/action_payloads.json`: `kept`, an object, may also be an array, which a passing `check_only` answers, and `content_notice` is new\. It also records the use on the member `received_sha256` of each `refused` item in `schemas/wire_errors.json`, on the rows `deploy_files_hash_mismatch`, `deploy_files_syntax_error`, `deploy_files_too_large`, and `invalid_request`, and `schemas/wire_error.schema.json`'s member region is generated again from the rows\. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

This statement records a use of MAPI\-02's shape clause on the members `kept` and `refused` of the rows `artifact_area_mismatch` and `artifact_not_found` in `schemas/wire_errors.json`, and on `deploy_files`' answer member `stored` in `schemas/action_payloads.json`\. Each row gains the two members, naming a list's entries kept and refused, and `schemas/wire_error.schema.json`'s member region is generated again from the rows\. The platform then held 3 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

MAPI\-27: The development purge is one row of the enumeration on the `account` resource, reversible tier, marked `grant: super_admin` \(MAPI\-09; API\-L0\-12\)\. For each of the calling account's own applications it names it runs the deletion walk `delete_application` runs after approval \(PLD\-L0\-66\), with no pending action and no browser approval\. That tier is decided here on the row's own ground: the applications are the caller's own, on the development estate, which holds no customer's account or data \(PLD\-L0\-85\)\.

The request names `applications`, one or more application ids, and no other member; another shape is refused 400 `invalid_request`\. An id the calling account does not hold, unknown or another account's alike, answers the state `not_held` and walks nothing\. The two are told apart for nobody here, though `delete_application` refuses them by their own names, `no_such_application` and `application_other_account` \(MAPI\-14\)\. Where one of the caller's own named applications carries a standing deletion marker, the whole request is refused 409 `deletion_in_progress` naming it and nothing starts; the retry is `delete_application` with its approval \(PLD\-L0\-66\)\. Otherwise the call answers 202 at once with each application's state, `walking` or `not_held`, and the walks run detached \(MAPI\-04\)\.

MAPI\-28: Two rows of the enumeration make one HTTP request to a route of the caller's own deployed application, each on the `environment` resource at the reversible tier \(API\-L0\-26\)\. `request_route` sends `GET`, and `write_route` sends `POST`, `PUT`, `PATCH`, or `DELETE`\. So a host, and a person approving a call, can tell a read from a write by the tool\. One handler answers both, and every guard, bound, and answer this statement states holds for both\.

Each request carries `application` and `path`, and `write_route`'s also carries `method`\. `request_route` defaults `environment` to `production`; `write_route` requires it, and an omitted value is refused `invalid_request` naming `environment` before any request\. `request_route`'s optionally carries `method`, whose one value is `GET`, `GET` where absent\. The path begins with one `/`, runs to at most 2,048 characters, holds no space or control character, and may carry a query\. The request optionally carries `headers`, at most 16, each value a string of visible characters, spaces, and tabs, and `follow_redirects`, a boolean, true where absent\. `write_route`'s optionally carries `body`, at most 64 KiB\.

A call that sends a method through the other row is refused `invalid_request` naming the row that sends it\. `request_route` refuses any `method` but `GET` naming `write_route`, at the top level and in an entry of `routes`\. It declares no `body` at either place, and its `x-retired` sentence names `write_route` \(MAPI\-22\)\. `write_route` refuses a `method` of `GET` naming `request_route`, and refuses an absent or other `method` naming its four\. On the tool surface, a single tool call naming a `method` its row does not admit is handed to the dispatcher ahead of the argument layer, as MAPI\-22's call is, so this refusal answers it, each row named as the connection lists it\.

The caller may not set these headers, each refused `invalid_request` naming the header:<br>\- `accept-encoding`;<br>\- the hop headers `host`, `content-length`, `transfer-encoding`, `connection`, `keep-alive`, `upgrade`, `expect`, `forwarded`, and `via`;<br>\- any name beginning `x-forwarded-`, `x-azure-`, `x-fd-`, `x-envoy-`, `x-k8se-`, `x-ms-containerapp-`, `x-turnzero-cloud-`, or `x-app-cloud-`, the families EGW\-L0\-03 removes\.

The one name of those families the caller may set is `x-turnzero-cloud-client`, the app's client\-version header \(SVC\-L0\-11\), which reaches the application as sent, so a route check meets a native client's version gate as the client does\.

The plane composes the address from the environment's managed hostname under the estate's serving suffix \(SVC\-L0\-07\) and takes no host from the caller\. It resolves the name, admits public unicast addresses alone, and dials the address it checked \(EGW\-L0\-01, its classes EGW\-L0\-13's\)\. A name resolving to no address, or to an address outside public unicast, is refused `route_unreachable` before any connection\. A redirect is followed only to the same hostname over `https` on port 443, at most five hops, each checked the same way\. Any other redirect, one naming another port among them, is answered as the result, and so is every redirect of a request naming `follow_redirects` false, so a caller can check that a page redirects, with `redirects` 0\. A 303 answering any method but `GET`, and a 301 or 302 answering a `POST`, is followed with a `GET` and no body\.

The request carries the caller's headers and body, the client library's defaults where the caller sets none, and no header or credential of the platform's\. `accept-encoding` is always `identity`, and a body the application encodes anyway is returned decoded\. The answer, status 200, carries `contract_version`, `reference`, `application`, `environment`, `method`, `url`, `status`, `headers`, `body`, `body_encoding` \(`utf-8` or `base64`\), `body_bytes`, `truncated`, `redirects`, and `elapsed_ms`\. `method` is the call's own, and `url` the last address requested\. Without `routes`, the body is returned up to 64 KiB, or the lower `max_body_bytes`, counted after any decoding, past which the connection ends and `truncated` is true, and the call ends within 20 seconds, past which it is refused `route_unreachable` with the reason `timeout`\.

Where `status` is 400 or more and the answered headers carry `x-request-id`, the answer also carries `detail`\. It names the reads that find that request's records, the value and the request's start filled in, in the order the guide Read logs and counters gives\. The first is one `read_logs` with the field `request_id`, no source, `since`, and `wait_seconds` 10, which returns a 5xx's router record and the entries the application wrote with a `request_id` field \(MAPI\-04\)\. Then comes the source `container` from the same start, which needs no id, with `contains` only for a line that prints the value, because a console line carries the value only where the application prints it\.

The request optionally carries `routes` in place of the members a single request sends: `method`, `path`, `headers`, and `follow_redirects`, and on `write_route` `body`\. It is a list of one to five entries, each holding those members, checked as the single request's are, an entry's refusal naming its place\. So a list runs under one row, and reads and writes together take two calls\. An entry may also carry `expect`, the status from 100 to 599 it is expected to answer, any other value refused `invalid_request` naming its place\. A call naming `routes` beside any of those members is refused `invalid_request`\.

The entries are requested in order, each counted as one call toward the account's sixty a minute, the one window both rows count in\. With `test_end_user`, one sign\-in serves every entry\. Each entry keeps its 20\-second bound, the whole list ends within 60 seconds, and each body is returned up to 12 KiB\.

With `routes`, the answer carries `results` and `failed` in place of the single request's members from `method` to `detail`\. Each result carries those members, or, for an entry refused `route_unreachable`, `method`, `url`, and `refused`, holding the refusal's `error`, `reason`, and `detail`, the next entry still requested\. `failed` counts the results refused, those of an entry with `expect` answered with another status, and those of an entry without it answered with a status of 400 or more\. Where `failed` counts an entry without `expect` that answered 400 or more, the answer also carries `note`, at most 200 Unicode code points\. It gives the number of those entries and says to set `expect` to the intended status to count a matching result as passed\. Refused entries answered no status and are excluded from this number\. A result of an entry with `expect` also carries `expected`, true where its status equals it\.

The request optionally carries `max_body_bytes`, a whole number from 0 to 65,536, which lowers the bound each body is returned up to, so a large page fits a tool's output limit\. Under `routes` it never raises an entry's 12 KiB\. At 0 the answer carries the status and headers with an empty `body`, `truncated` true where the application sent any byte\. Any other value is refused `invalid_request` before the rate window and any request\.

The request optionally carries `test_end_user`, a test end user's id or label as `sign_in_test_end_user`'s `end_user` takes it, with `environment` given \(ACS\-L0\-21\)\. It is admitted for the calling credential as the creation is \(ACS\-L0\-21\): refused `test_end_users_disabled` while `TEST_END_USERS` reads off\. A minted token without the `test_end_users` grant is refused `test_end_users_not_admitted` on a production realm and on a workforce realm\. The account's session and a token carrying the grant are admitted on every realm\. A user who is not an unexpired test end user of the realm is refused `not_test_end_user`, an id no user holds `no_such_end_user` \(MAPI\-15\), and an application declaring no accounts service `realm_not_declared`\.

The plane signs the test end user in through the command's own sign\-in, held to the address's sign\-in limits \(ACS\-L0\-12\) and the realm's per\-source rate on sign\-in starts under the caller's source address \(ACS\-L0\-07\)\. The session lives at most 60 seconds\. `request_route` and `write_route` optionally carry `session_as`, `cookie` or `bearer`, `cookie` where absent\. With `bearer`, `Authorization: Bearer <value>` replaces the cookie on the request and each same\-host redirect\. Otherwise its cookie rides them\. The plane ends the session when the call ends, answered or refused, waiting at most five seconds for the ending\. A refused sign\-in is refused by its own name: `signin_code_rate_limited` past the address's `code_sends_per_hour`, `signin_rate_limited` past the realm's `signin_starts_per_hour`, `user_suspended`, `route_not_enabled` where the realm admits no sign\-in, `signin_code_invalid` where the held code does not confirm, or `invalid_request`\.

Where the management and accounts services are separate processes, the sign\-in and the ending run on the accounts service through its marked routes, as ACS\-L0\-21 states\. A call that service does not complete or answers by no name of the sign\-in's own, or one made where the secret or the address is absent, is refused `test_end_user_sign_in_unavailable` \(503\), signing nobody in and requesting nothing\.

The plane replaces the session's value wherever it appears unencoded in the answered `url`, headers, and body, a `set-cookie` under the realm session's name among them\. A value the application returns encoded, such as in base64, is not replaced\. A `cookie` header beside `test_end_user` is refused `invalid_request`\. A caller's `authorization` header with `session_as` `bearer` is refused likewise\. A `session_as` without `test_end_user` or with any value other than `cookie` or `bearer` is refused `invalid_request` before any request\.

One account makes at most 60 such calls a minute across both rows, past which the call is refused `rate_capped` \(PLD\-L0\-67\)\. The call refuses `no_such_application` for an id no account holds and `application_other_account` for another account's \(MAPI\-14\)\. It refuses `environment_not_created`, and `never_deployed` \(PLD\-L0\-59\) where the environment serves no version\. `route_unreachable` carries `reason`: `no_address`, `address_not_public`, `connect_failed`, `tls_failed`, or `timeout`\. The record's subject is the application, the environment, the method, and the path, its query left out, each entry's for a list, and never the headers or the body \(MAPI\-06\)\.

This statement records a use of MAPI\-02's shape clause on `request_route`'s request, at the top level and in `routes` entries: `method` narrowed to the one value `GET`, and `body` removed, `write_route` sending what they sent\. The owner approved the split, and `request_route` keeps its name\. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, `schemas/mcp_surface.json`, and `schemas/wire_errors.json` move with it\. The platform then held 6 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

MAPI\-29: The support read token lets the support agent read one account's own state for one chat, only because the account's owner asked: a summary, and the wider reads below, each cut to an allow\-list\. It is a minted token carrying the one grant `support_read`, and nothing else mints it: `mint_token` refuses the grant as it refuses any grant outside its list \(MAPI\-14\)\.

The management service serves the routes under `/api/v1/support/`, none of them a management action: the four this paragraph and the next three state, the wider reads the paragraphs after the summary state, and the Questions page's chat routes the paragraphs after the bounds state\. The service also serves the hand\-off route MAPI\-35 states\. `POST /api/v1/support/chats` answers a chat id: a public id `sc_` followed by 22 base64url characters, a dot, and an HMAC\-SHA256 of the public id and an account's identifier under a key derived from the browser credential secret\. Under the support cookie of a signed\-in browser \(WEB\-L0\-16\), verified as the site gate verifies the site cookie, the id is signed for that account; otherwise it is signed for no account, and no grant attaches to it\. The answer names `bot_check` and `visitor_chat` besides, as the chat paragraphs state\.

`POST /api/v1/support/consent`, a same\-origin JSON post under the support cookie of a signed\-in browser naming `chat`, is the visitor's consent\. A chat not signed for the cookie's account is refused 403 `chat_not_yours`, a request with no admitted cookie 401 `authentication_required`, and a suspended account 403 `account_suspended`, each with nothing minted\. Otherwise the route revokes the chat's live support read token, if any, and mints one: account scope, the grant `support_read` alone, the label `Support chat <public id>`, and an expiry 60 minutes after the mint\. It posts the token's value, the chat's public id, and the expiry to the support agent's bridge \(the next paragraph\)\. The answer names the chat's public id, the token's identity, and its expiry, and never the value\.

Where the estate names no bridge or holds no browser credential secret, the route answers 503 `support_unavailable` with nothing minted; where the bridge does not answer 2xx within 5 seconds, the token is revoked at once and the route answers 502 `support_unreachable`\.

The bridge is named by the settings `SUPPORT_BRIDGE_ORIGIN`, an https origin or http on a loopback host, and `SUPPORT_BRIDGE_SECRET`\. Each call is a JSON post to `/support/account-grant`, `/support/account-grant/end`, `/support/chat`, `/support/chat/stream`, or `/support/chat/rate` \(MAPI\-32\) carrying the header `x-turnzero-support-signature: t=<unix seconds>,v1=<hex>`, the HMAC\-SHA256 of `<t>.<body>` under the secret\. The bridge admits a call whose signature holds within 300 seconds of its clock\. The token's value reaches the bridge alone: never the browser, a chat message, or the model\.

`POST /api/v1/support/consent/end` naming `chat`, under the same cookie, revokes the chat's live support read token and tells the bridge to drop it, best effort\. A browser's sign\-out that ends a live session row of the account \(ACS\-L0\-18\), and `sign_out_everywhere`, revoke every live support read token of the account on every chat, and tell the bridge to drop each, best effort\. A sign\-out under a cookie whose row is already revoked ends nothing\. `revoke_token` ends one as it ends any token, and `list_tokens` lists it, its label naming the chat\. An account's erasure ends it with the account's other tokens \(API\-L0\-05\)\. On those last two ends the bridge is not told: the plane's refusal of the token is the authority\.

`GET /api/v1/support/account` under the support read token as a bearer answers the public id of the chat the token was minted for, as `chat`, and one summary of the token's own account\. The summary is cut to an allow\-list from the readers the customer rows read, and holds these parts:

- the account's identifier, creation, standing and products;
- at most 20 applications, each with its identifier, name, label, size, state, serving version, creation, and each environment's name, state, serving version, and hostname; `unlimited` is present and true on the company's own applications alone;
- each application's production compute state, restart count, and server\-error counts;
- each application's 5 newest versions' environment, number, kind, state, stamps, and, for one that did not succeed, the result, step, and error name alone;
- the usage period with each application's state, measures, and limits;
- `credit.grants`: at most 20 grants of this account, newest first, each holding these members:
- `id`;
- `source`;
- `purchase`, the plane's purchase identifier or null;
- `granted_at`;
- `expires_at`;
- `amount_micros`;
- `left_micros`;
- `spent_micros`\.

A grant's spent amount is its amount less what is left and what removals took, net of restores, never below zero\. The credit part answers no operator reason or name, no provider identifier, and no refunds member\.

The summary never answers a secret or a setting's value, a token, a sign\-in address, an identity, a passkey, an end user, a log line, a request path, build output, or a detail's free text\. Any other bearer, or none, is refused 401 `authentication_required`, and a token of a suspended account 403 `account_suspended`\.

The wider reads are `GET /api/v1/support/<read>` under the same token, each answering `chat` beside its cut\. Each runs the existing action its customer row runs, an observe action or, for the issues read, `relay_issue_act`'s read acts alone, through the dispatcher under the token's own minted credential, and keeps only the members named here:

- `status` runs `read_status`\. It answers the application's identifier, label, size, described environment, state, and serving version\. `unlimited` is present and true on the company's own applications alone\. For each environment it answers the state, compute state, restart count, serving version, hostname, and halt\. It answers each deploy row's version, kind, state, and stamps, its outcome cut to the result, step, and error words\. It answers the described environment's server\-error counts, never their paths\.
- `versions` runs `list_versions`: each environment's serving version, and at most 20 rows, each its environment, number, kind, state, whether it serves, stamps, and outcome words\.
- `check` runs `check_deploy`: the application and environment checked, whether the upload was checked, and each refusal's name, status, the platform's sentence, and the next action's name\.
- `logs` runs `read_logs` over at most the last 7 days and 500 entries, the answer within 200,000 characters\. Each entry answers its instant, its level as a word or nothing, its source, its message, and its fields\. Each message, field value, and console line is redacted: email addresses, telephone numbers, bearer values, JWTs, prefixed keys, and opaque strings of 32 characters or more but a UUID are replaced\. A field whose name names a person or a credential is dropped whole, the name read in its words whether written with `_`, `.`, `-`, or camelCase\. An answer past the bound is cut and marked truncated\.
- `counters` runs `read_counters`: each bucket's name, start, and total\.
- `settings` runs `list_secrets`, `list_storage_areas`, and `list_outbound_apis`, and, for a named application, `read_app_sign_in`, `read_push`, and `read_schedules`\. It answers secret and setting names, scopes, applications, environments, stamps, and whether a restart is needed, never a value or a fingerprint\. It answers each area's and upstream's name, kind, application, environment, and host\. It answers the realm's sign\-in methods, limits, invitation and session days, counts, secret names, and clients' identifiers and versions\. It answers push's configuration flags, secret names, counts, and the month's accepted count and quota\. It answers each schedule's name, cron, next due, whether it is deployed, and its run in flight, and of its last run and its 10 newest runs the trigger, stamps, outcome word, status, and duration, never a run's detail\.
- `database` runs `query_database` with fixed statements the route alone composes: each `public` table's columns, types, and nullability, its index names, and the applied names in a migration table the common tools write\. It never reads another row\.
- `issues` runs `list_issue_spaces` and `relay_issue_act`: the account's own spaces of kind `account` that no application's binding record names, and in one of them the relayed `list`, `search`, or `read` alone\. Any other space is refused 404 `not_found`, and any other act 400 `invalid_request` with nothing relayed\. Each relayed call reads that one space at `view` under the support token's own identity\. Restricted issues are absent from `list` and `search`; a `read` is refused 404 `issue_refused`, as for an identifier no issue carries\. For `read`, the query's `issue` member names the issue\. A relayed answer is the issue service's own, whole, within the answer's 200,000 characters\.
- `files` reads the deployed files of the serving version or the one before it: the application's tree at /app in the version's image, read from the cell registry under the management identity\. A file a newer layer deleted is not in that tree\. It answers the file list, at most 2,000 files, or one page of one file: at most 400 lines and 40,000 characters, a longer line answered in pages within it, each answer naming where the next page starts\. It never serves `node_modules`, an environment file, a binary file, or a file past 1 MB, and answers `not_found` where the image is no longer kept\.

A wider read with no `application` where its action needs one is refused 400 `invalid_request`, and a refusal of the action it runs is answered under that action's own name and status, the management action surface's row\. Where one of several actions a read runs is refused, as a part of `settings` or `database` may be, that part answers the action's name, status, and refusal name in place of its value\. Where the estate holds no dispatcher seam or no image reader, a read answers 503 `support_unavailable`\.

One support read token reads at most 30 times in a UTC minute\. One chat reads at most 600 times in any 60 minutes, across every token the chat held, so a new consent click resets nothing\. Each read of a route counts once against the token's minute, before any other read of the account\. It then counts once against the chat's hour only where the chat's count stands below its bound\. So a read either bound refuses never counts against the hour\.

A read past either bound is refused 429 `support_read_rate_capped` with nothing read, and the refusal is recorded under the token's own identity\. The answer carries `retry_after` and the header `Retry-After`, each the seconds to wait:

- past the token's bound, to the next minute;
- past the chat's bound, until enough of the chat's oldest counted minutes leave the trailing 60 for a read to pass\.

The counts are rate windows keyed on the token's identity and on the chat's public id, shared across the plane's replicas as the admission window's are\. So they may pass a bound by one flush interval's reads per replica, and the admission window counts each request by its source besides \(PLD\-L0\-67\)\.

The consent needs no fresh sign\-in \(MAPI\-03; WEB\-L0\-16\)\. It stands under the support cookie of the signed\-in session, which a browser sends to `/api/v1/support/` alone\. The token reaches that account's own observe reads, cut to the allow\-lists above, and its deployed files, never a management action that writes and never past the account\. Its only sending act is the hand\-off MAPI\-35 states\. It ends at any of the account's browser sign\-outs that ends a live session row, that session's among them\.

`POST /api/v1/support/chats/message` is one message of the Questions page's chat\. It is a same\-origin JSON post naming `chat`, a chat id the chats route answered, and `text` of 1 to 4,000 characters\. A signed\-out message on an estate that names a bot check carries `bot_token` besides\. A chat id of another form, or a text outside its bounds, is refused 400 `invalid_request`\.

The route reads the support cookie as the consent route reads it\. A chat signed for the cookie's admitted account is a signed\-in chat, and the support application is told the account\. A chat signed for no account is a signed\-out chat, whatever cookie the request carries, and the application is told no account\. A chat signed for neither is refused 403 `chat_not_yours` with nothing sent: a forged mac, or a chat started signed in whose session has since ended, been suspended, or signed out\. So no signed\-out message continues a signed\-in conversation, and the page starts a new chat\.

The bot check is Cloudflare Turnstile, named by the settings `SUPPORT_BOT_CHECK_SECRET` and `SUPPORT_BOT_CHECK_SITE_KEY`\. On a signed\-out message the route posts the token, the secret, and the visitor's address to Cloudflare's verification route\. The check passes where the answer says so, and not otherwise\. A message with no token, or one the check does not pass, is refused 403 `bot_check_failed`, and nothing is sent\. A signed\-in chat needs no check: its session is the check\.

Where either setting is unset, the estate names no check, and a signed\-out message runs unchecked, on either estate alike; the support application's caps bound it \(the support member's statements\)\. The chats route tells the page how a signed\-out chat stands, as `visitor_chat`: `checked` or `unchecked`\. It names the check's kind and public site key as `bot_check`, or null where the estate names none\. The plane writes one diagnostics line, `support chat bot check off`, at its start where no check is named\.

A message admitted is posted to the bridge's `/support/chat`, signed as every bridge call is, with:

- the chat's public id;
- the account, or null;
- the text;
- a turn id of the route's own, `st_` and 22 base64url characters;
- an address key, a hash of the request's source key under a fixed purpose word, so the application never holds an address\.

A bridge that does not answer within 10 seconds is answered 502 `support_unreachable`\. An estate naming no bridge or no browser credential secret answers 503 `support_unavailable`\.

The route answers the browser a stream of server\-sent events:

- `turn`, naming the turn, the chat's public id, and whether the chat is signed in;
- `progress`, the plane's own first line, then each line the application reports as the agent calls a tool;
- `draft`, the answer as the agent writes it, which a later `draft` or the first `text` replaces and which moves no offset;
- `text`, each part of the answer as it arrives;
- `done`, with the turn's end\.

A message the application answers at once with a cap's or a failure's line is streamed `limit` or `failed` with that line, then `done`, with no further call\. The caps are the support application's, and a message past one is the chat's answer, never a refusal\.

The application holds one response open per watched turn at `/support/chat/stream` \(support\_agent:SUP\-13\), and the plane reads that response until `done`, with no read on a timer\. Where the response drops, the plane attaches again by its offsets, 2 seconds later\. A refused attach, or a response that ends with no event inside 30 seconds, says nothing of the turn\. A run of them past 75 seconds ends the stream `failed` with the line that says to try again, and an attach answered 400, 401, or 403 ends it so at once\. A response held 30 seconds or more that ends with no event is a healthy hold that dropped, and it ends the run\.

A stream open 120 seconds ends with `timeout`\. The page then reads the turn by `POST /api/v1/support/chats/stream`, a same\-origin JSON post naming `chat`, `turn`, and optionally `text`, the characters of the answer it already shows\. It answers the same stream past that offset, `turn` first, and 404 `not_found` where its first attach finds a turn the chat does not hold\. Where a later attach finds that, the stream ends `failed` with the same line\. A `done` with the state `superseded` ends the stream where the chat has moved to another turn\. On these two posts the support cookie is read as the consent route reads it\. A request with no cookie is a signed\-out chat's, never refused for the cookie's absence\.

A chat message writes no record row: the conversation's record is the support application's own log\. The plane writes a diagnostics line for a failed bot check, `support chat bot check failed`, and for a bridge not reached, `support chat not delivered`, each naming the chat's public id and never the text\.

The refusals `chat_not_yours`, `support_unavailable`, `support_unreachable`, `support_read_rate_capped`, and `bot_check_failed` are this statement's rows of `schemas/wire_errors.json` \(MAPI\-15\), on its surface `support_read`, beside the rows of `authentication_required`, `account_suspended`, `rate_capped`, `internal`, `invalid_request`, and `not_found`, which name that surface too\.

Each read writes operational record rows under the token's own identity \(MAPI\-06\): the account, the credential kind `minted_token`, the token's identifier, the act, and the outcome\. The summary's act is `support_read_account`\. Each wider read admitted at the bounds writes one row as `support_read_<read>`, its outcome `completed` or the refusal's name\. That row is written for a read refused before any action, and for one failing on the platform's side\. Each action a wider read runs writes its own row besides, under its own name, as the dispatcher writes every call\.

The consent and Stop sharing of a signed\-in, active account each write a row under the browser session, which carries no identity of its own \(MAPI\-06\), the acts `support_read_grant` and `support_read_end`, the outcome `completed` or the refusal's name\. An end at a sign\-out is that sign\-out's own act and writes no row of its own\. Each consent writes one control\-plane diagnostics line, `support read granted` or, where the delivery failed, `support read not delivered`\. Each token that a second consent in its chat, Stop sharing, a sign\-out, or sign out everywhere ends writes `support read ended`; a token ended by `revoke_token` or erasure, or at its expiry, writes none\. Each line names the account, the token's identity, and the chat's public id, never the value \(system:LGS\-L0\-16\)\.

MAPI\-35: **The support agent's bridge can send a hand\-off email for an account's chat under that chat's own support read token\.** It calls `POST /api/v1/support/handoff` with that chat's support read token as a bearer\. The route is no management action and appears in no AI tool list\. It uses MAPI\-29's support\-read gate, including the token's minute and the chat's hour: a hand\-off counts once against each bound\. It grants no management write, writes no ledger row, and mints nothing\.

The body admits `chat`, `asked`, and optional `purchase` alone\. Any other member is refused 400 `invalid_request`, with nothing sent\. The `chat` is an unchanged string of at most 64 UTF\-16 code units and must equal the token's own chat; another is refused 403 `chat_not_yours`\. The `purchase`, where present and not null, is an unchanged string of 1 to 64 ASCII letters, digits, underscores or hyphens\. A malformed value is refused 400 `invalid_request`; a value naming no purchase of that account is refused 404 `not_found`\.

The `asked` is a string\. CRLF and CR line endings become LF\. C0 controls other than tab and LF, DEL, and Unicode line and paragraph separators become spaces\. The result is trimmed and must hold 1 to 2,000 UTF\-16 code units, else the route refuses 400 `invalid_request`, with nothing sent\.

The plane writes the recipient, reply address and subject\. The recipient is the estate setting `SUPPORT_HANDOFF_MAILBOX`, the testing mailbox on development\. Where it names no admitted mailbox, the route refuses 503 `support_unavailable`\. The reply address is the account's earliest\-bound verified address among those the balance warning reads, read at the send\. The message names the account, chat and UTC day, the purchase where named, and what was asked\. The purchase's part names its plane identifier, state, pre\-tax amount and start instant, with the paid instant where one stands\. The message carries no link; its HTML escapes every supplied value\.

One email is admitted for an account in a UTC day, across its chats and tokens\. Before sending, the plane claims the account and day's place under that key's lock\. A pending claim is marked sent only after the sender takes the message\. A sent claim answers 200 with `outcome: already_sent`; a pending claim answers 200 with `outcome: not_sent` and `reason: in_progress`\. A successful send answers 200 with `outcome: sent`\. No answer names the mailbox, reply address or claim\.

A hand\-off takes one place in ACS\-L0\-13's balance\-warning window, counted under that window's turn\. It takes nothing of the sign\-in ceilings\. A zero window or absent sender answers 200 `not_sent` with `reason: window_closed`; a full window answers `reason: window_full`\. No verified reply address answers `reason: no_address`\. A send that fails or times out after three seconds answers `reason: send_failed`\. Where the sender has not confirmed acceptance, the plane releases any claim it took; the day's place stays free\. After a timeout the provider may still deliver the email, so a later ask that day may send another\.

Two claim faults remain\. A failed release after a failed send leaves a pending claim; after sixty seconds that claim no longer holds the day's place\. A failed sent mark after a taken send leaves a pending claim too: after sixty seconds a later ask may send another email\. The plane prefers that duplicate to a lost hand\-off\.

The plane attempts to append an operational record naming the act `support_handoff` and its outcome under the token's identity \(MAPI\-06\)\. If that append fails after a successful send, the route still answers 200 `sent`\. If it fails after a send the sender did not confirm, the route still answers 200 `not_sent` with `reason: send_failed`\. In either case it adds a diagnostic warning, and the operational record is absent\. If the call attempted no send, an append failure still fails the call\. The diagnostics name the account, token, chat and outcome\. Neither record carries an address or the asked text\. The claim is kept in the builder realm's account event log on ACS\-L0\-02's terms\.

MAPI\-30: `check_app_sign_in` is one row of the enumeration on the `realm` resource at the observe tier, read\-only and open\-world and not idempotent, since each call writes meter rows \(ACS\-L0\-24\)\. Its request carries `application` and `environment` \(`production` where absent\), and nothing else\. The answer, status 200, carries `contract_version`, `reference`, `application`, `environment`, `sign_in_page`, `routes`, `detail`, and `page`, the guide Add work\-account or Apple sign\-in\.

`sign_in_page` is the address of the realm's sign\-in page the check requested\. `routes` holds one entry for each of `entra` and `apple` the realm configures, in that order, and is empty where it configures neither\. Each entry carries `name` and three objects, `credential`, `provider`, and `route`, each carrying `outcome` as ACS\-L0\-24 gives it\. `provider` also carries `error` where it is `refused` and `status` where it is `unknown`\. On Entra's `refused` and status\-bearing `unknown` outcomes it also carries `code` where the first `error_codes` entry is a positive integer\. The number can choose the step under ACS\-L0\-24\. The outcome does not depend on it\. Apple carries no `code`\.

`route` also carries `status` where it is `not_serving` or `unknown`\. An entry that needs a step carries `detail`, the step ACS\-L0\-24 gives for each of its outcomes needing one, in the order credential, provider, route\.

Where a credential is `not_moved` and the recorded manifest's `realm` member gives that route's credential, the answer carries `next`: the one `submit_manifest` call with the application and the recorded manifest \(MAPI\-24\)\. The answer's `detail` gives the routes checked and which of them need a step\.

One account makes at most ten such calls a minute, past which the call is refused `rate_capped` before any credential is read, provider called, or page requested \(PLD\-L0\-67\)\. A check past the accounts service's window of ten checks a minute for each realm is refused `rate_capped` too\. The call refuses `invalid_request`, `no_such_application` for an id no account holds and `application_other_account` for another account's \(MAPI\-14\), `environment_not_created`, and `realm_not_declared` where the application declares no accounts service\. Where a route goes to the accounts service and the build reaches none, or that service does not answer the check, the call is refused `realm_check_unavailable` \(503\), nothing checked \(CRD\-34\)\. A route whose credential is `not_moved` goes to no accounts service, and neither does a realm configuring neither route\.

MAPI\-34: `check_manifest` is one row of the enumeration on the `application` resource at the observe tier \(API\-L0\-24\), read\-only and not idempotent, since each call writes meter rows\. Its request carries `application` and `manifest`, and nothing else\. It runs the checks `submit_manifest` runs before its custom\-domain write, through the one function the submission runs\. It refuses as that submission refuses the application, the manifest, and a deletion in flight, each refusal naming `check_manifest` as its action\. The custom\-domain write's own refusal lies outside its reading, as the pages state\. It records no manifest, writes no custom\-domain row, runs no setup step, and mints nothing, and it is recorded as an action like every action \(MAPI\-06\)\.

Its answer, status 200, carries the contract version, the application, `outcome` \(`checked`\), `changed`, `difference`, and `detail`\. `changed` is true where the manifest differs from the recorded one or none is recorded\. `difference` carries `added`, `removed`, and `changed`, each a list of paths in the form MAN\-12's refusals name\.

MAPI\-32: **The Questions page's chat rates each answer through the plane, and each chat message names its browser by a hash, never by a value the support application could reuse\.** `POST /api/v1/support/chats/rate` is a same\-origin JSON post naming `chat`, `turn`, and `rating`, `up` or `down`\. The route reads the support cookie and the chat id as the message route does \(MAPI\-29\)\. It passes the chat's public id, the turn, and the rating to the bridge's `/support/chat/rate`, signed as every bridge call is, and answers the chat's public id, the turn, and the rating\. A turn the bridge does not hold is answered 404 `not_found`\. Another rating, or a turn id of another form, is answered 400 `invalid_request`\. A bridge that does not answer is answered 502 `support_unreachable`\. An estate naming no bridge, or a bridge answering 503, is answered 503 `support_unavailable`, and a bridge answering 400 is answered 400 `invalid_request`\.

The message route keeps the support browser cookie, `__Host-turnzero_cloud_support_browser`: a random value of 22 base64url characters, HttpOnly, Secure, SameSite=Lax, on the root path, living 90 days\. The route sets it where the request carries none of that form\. Each message it posts to the bridge names a browser key, a hash of the cookie's value under a fixed purpose word, so the support application never holds the value\. On a signed\-in chat the message also names the account's creation time, the account row's `created_at`\. The support application uses the two to name the account a browser's earlier chats led to\. A synthetic account's message \(ACB\-L0\-79\) also carries `synthetic` true, and the support application keeps no row of it \(support\_agent:SUP\-14\)\. A rating not passed on writes one diagnostics line, `support chat rating not delivered`, naming the chat's public id and the turn and never the text\.

MAPI\-31: \*Retired 2026\-10\-29 UTC\.\*

MAPI\-33: The management actions are also served as an OpenAPI 3\.1 document, generated with the human reference from the indexed sources \(API\-L0\-09; CTX\-03\)\. The site render writes it at `/cloud/openapi.json` \(PLD\-L0\-69\)\.

It holds one `POST` operation for each action that has an entry in `schemas/action_payloads.json`, whose clients admit a bearer token and that carries no grant, with the action's request and response schemas and the `management_action` refusal names\. Its `info.version` is `management_api.json`'s `version`\. Its `servers` entry names the estate's tzCloud base, and each account or plane\-made tzTrack row's path states the base its estate serves it at, each written from one map, so a change of an address moves it in one place\.

MAPI\-36: An action\-registration module under `src/handlers/` exports only its register function\. `buildAppParts` creates the registration context and passes it only to the register functions; the context appears on no exported object, `BuiltApp` included, and in no log\. A handler that a module under `src/handlers/` registers can be called only through the action map and the dispatcher's checks of level, grant and approval \(MAPI\-04; MAPI\-09; MAPI\-11\)\.<br>

## Source Markdown

```text
---
document: management_api_contract
prefix: MAPI
---

# The Management API — Resource Contract

## Purpose

This file is the resource contract for the one management API the management API PRD describes: the resources the plane exposes, the actions over them, how the contract is versioned, and how a credential binds to it. It is the layer the MCP surface derives from: the tools of `mcp_surface.md` are these actions, surfaced (MCP-03). A test in the platform's suite holds the two enumerations to each other — an automated check of API-L0-01's requirement that each client expose only capabilities of the management API.

The launch enumeration has one home: `schemas/management_api.json` beside this document — the resources, and action by action the resource it operates on, its authority tier, and which clients may call it. This document states the rules the enumeration obeys and repeats none of its rows.

What this document does not cover: the per-action payload schemas, which land with each action's implementation (raised below; the route rule, methods, and error shape are MAPI-10's); the served three-form derivation of API-L0-09, `served_context.md`'s; and the pending action's own mechanics, which stay API-L0-07's.

Requirements are numbered MAPI-nn.

## The contract

MAPI-01 (decided): The management API is one versioned HTTP contract of resources and actions: every capability is a read of a resource or an action upon one, and every resource and action is enumerated in `schemas/management_api.json`. A capability enters the plane by entering that enumeration. There is no unenumerated endpoint for a surface to lean on, which is what keeps every surface a client (API-L0-01).

MAPI-02 (decided): The contract carries its version — `1` at launch — stated in every exchange. Within a version, evolution is additive: new resources, new actions, new optional fields. Removing or renaming anything, or changing an action's tier, is a new contract version, never a quiet edit — the callers are AI coding tools acting on this contract's served descriptions, and a description that drifts under a caller is a capability that lies.

Removing a request member within a version is a change a caller observes, since a call that names a member its action does not declare is refused (MAPI-22). So a removal is admitted only as a use of the shape clause below while that clause runs, and is a new contract version after. One removal was made before that rule stood, when a caller that sent the member observed no difference in the call's answer. It took the optional `request_id` member, which no implementation ever read, from twelve reversible request schemas in `schemas/action_payloads.json`, named in MAPI-04. The HTTP route holds a call's member names to the request schema and validates no member's value.

Until the platform holds one hundred builder accounts that each hold a live application, a member's shape may change within version 1 in the interest of a cleaner contract. A synthetic account (ACB-L0-79) is not a builder account for this count. A change that removes or renames nothing needs no separate approval under the owner's standing ruling. A rename or removal needs the owner's approval by name.

While the clause runs, an action renamed under that approval answers `unknown_action` at its old name on the actions route, naming the successor. Its tool surface follows MCP-08's revision move. An action removed under that approval answers `unknown_action` at its old name; its tool surface follows the same revision move.

The session records the account count at the change and records the change in this document — by the statement that owns the member, or by this statement where none does. The served schema's version member moves at the change's landing, so that a caller regenerates its view. The platform's own callers change with the member, and no served description drifts under a caller it was made for.

The records carry ordinals from the first to the eighty-ninth, each the name a citation gives its use, and the numbered series closes there. A later use's record carries no ordinal and names the member it changes. In this statement it opens `This clause's use on`, and in the statement that owns the member it opens `This statement records a use of MAPI-02's shape clause on`. So two branches that each record a use record two, and every ordinal a citation names keeps its use.

Every content change to a served schema file moves that file's `version` member. The served schema files are the files the index `schemas/served_context.json` names, itself among them, that carry a top-level `version` member, a date and a counter. A description's wording and an enumeration widened to values the service already answers are included, because the served descriptions are the contract an AI caller acts on, and one version string naming two contents is the drift this statement forbids. An entry of the words override file (PLD-L0-114) is no content change to a served schema file and moves no version, so a listing's words can change under an unmoved version while the entry stands.

No session writes the member: on a session branch the registrar refuses a revision that changes it. The served `integrate` writes the next value at the landing into each such file whose bytes differ from the trunk's. The next value is the trunk's value with its counter plus one, or the landing day's UTC date with the counter 1 where that day is later than the trunk value's date (kit:REG-15; kit:REG-88). So the rule is mechanical, no session judges which changes move it, and two branches that revise one file land as consecutive values. `schemas/library_catalog.json`, the catalog's shape and not its rows, carries no `version` member, lands byte for byte, and rides CTX-01's suite.

Because the value is written at the landing, a control-plane release never carries an unlanded change to a file that declares the member. The control plane's release script (PLD-L0-65) fetches the remote trunk and refuses a release whose HEAD holds such a file in bytes the remote trunk's first-parent history does not hold at that path, or whose working copy of such a file differs from HEAD's. The branch is integrated first, and the release then runs from the landed trunk commit.

The rule holds on every estate the register names (PLD-L0-85). A development-role estate is released to from the landed trunk as production is, so a promote of its build to production (PLD-L0-65) carries forms the trunk holds.

The fetch must succeed, except in a rollback. There, where the fetch fails, the script reads the remote-tracking ref the clone holds, admits the rollback only where every such file stands at that ref's tip or in its first-parent history, and says that the fetch failed and the held ref vouched. The exception stands because a ref the run could not refresh holds a past value of the remote trunk, which can only under-report what landed, and a rollback is the act an incident needs.

A widened response enumeration is a member's shape change under the clause above, recorded as one of its uses. This clause's first use: the `environments` member of `list_applications`'s response in `schemas/action_payloads.json`, an array of environment names becoming an array of objects, each an environment's name, state, serving version, and hostname, when the platform held one builder account.

This clause's second use: the `state` member of each environment in `list_applications`'s response in `schemas/action_payloads.json`, an enumeration of three values — `deploying`, `deployed`, `never_deployed` — becoming one of five with `halted` and `deleting` added. The platform then held one builder account. It is recorded here because no statement of this contract owns the member.

This clause's third use: the `source` member of `read_logs`'s request in `schemas/action_payloads.json`, whose value `all` (three console logs merged by time) and whose omission (the `app` and `platform` sources) became the application's stream whole, every source the logging store holds. The platform then held one builder account. It is recorded here because no statement of this contract owns the member.

This clause's fourth use: `submit_manifest`'s response members `credential` and `platform_credential` in `schemas/action_payloads.json`, answered on the wire surface alone and withheld on the MCP surface, the member `credentials` added to state which form the answer took. The same use made `rotate_secret`'s request member `value` optional for the two platform-minted re-mints. The platform then held two builder accounts. It is recorded here because SEC-L0-07 and DBS-L0-02 own the members and neither is a statement of this document.

This clause's fifth use: the cutover of the platform's wire vocabulary to the product's public names (CQ-44). That vocabulary is the headers the serving router sets and the control plane reads, the settings the deploy injects, the OAuth scope, the credential prefixes and the browser cookies, and the product profile value. It is a change that stops every application built before the release until its owner rebuilds it and refuses every credential issued before the release, admitted by API-L0-16 as amended. The platform then held two builder accounts that each held a live application (three live applications in all, two on the operator's account and one on the second account). It is recorded here because the change reaches every member and no one statement of this contract owns it.

This clause's ninth use, the wire error shape's members, is recorded by MAPI-10, the statement that owns the shape, as is every later use that changes a refusal's members, the fourteenth and the thirty-second among them.

This clause's nineteenth use: the `issue_tracking` member of `submit_manifest`'s response in `schemas/action_payloads.json`, each environment's entry losing its `origin` and `settings` members and keeping the space's identifier and its outcome. No setting of the issue service is injected any more: an application reaches its space through the egress gateway's `issue-tracking` upstream, which presents the space's token (EGW-L0-06). The platform then held one builder account that held six live applications, the synthetic estate's one account aside (read from the production control database's rows). It is recorded here because ITS-L0-01 owns the member and is not a statement of this document.

This clause's twenty-second use, the narrowed range of `wait_seconds` on `read_status` and `read_schedules`, is recorded by MAPI-04, the statement that owns the member.

This clause's thirty-third use: `deploy`'s request and its answer to the preparing call in `schemas/action_payloads.json`. The answer's `upload` loses `address` and `commands` and gains `command`, the one line that runs the turnzero-cloud command (PLD-L0-94). The request gains `zip_sha256`, which every preparing call must name, a call without it, or with a value of another form, refused `zip_sha256_required` on every surface. The request's `local_path` gains a pattern refusing the characters a shell would change inside the line's double quotes, its absence naming the folder the line runs in, not `app.zip`. Over MCP a `local_path` outside the pattern draws the argument's validation error before the handler. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, `schemas/mcp_surface.json`, and `schemas/wire_errors.json` move with it. The descriptions moved when the platform held one builder account, which held six live applications. It is recorded here because PLD-L0-86 owns the members and is not a statement of this document.

This clause's thirty-fourth use, the `value` member of `store_secret`'s and `rotate_secret`'s requests marked `x-wire-only` and leaving both tool shapes, is recorded by MAPI-08, the statement that owns the argument derivation.

This clause's thirty-ninth use: the `application_spaces` member of `export_account`'s `feedback` in `schemas/action_payloads.json`, renamed `spaces`, each entry gaining `kind` and its `application` and `environment` admitting null. The member carries the account's own filings from each space the account owns, binds, or holds in custody for a standing pair. The description in `schemas/action_payloads.json` moves with it. The platform then held one builder account and six live applications, a synthetic account aside, read the same way at the change. It is recorded here because ACB-L0-47 owns the member and is not a statement of this document.

This clause's forty-sixth use, the preparing form of `store_secret` and `rotate_secret` and the members their requests and responses gained for it, is recorded by MAPI-08, the statement that states that form.

This clause's fiftieth use, the refusal of a call that names a member its action does not declare, is recorded by MAPI-22, the statement that owns the rule.

This clause's fifty-fourth use: `submit_feedback`'s `issue` member and three refusals on the platform's own space, for a credential that does not read the queue. The member is null where MAPI-18 withholds the issue, where it was an object in every answer. The recovered mark answers the member's `id`, `status`, and `disposition` alone, where it answered the issue as the 0.2.0 wire gives it. A confirmation that names a restricted issue, and a recovered mark MAPI-18 does not relay, are refused where each was relayed. The description in `schemas/action_payloads.json` moves with it. The platform then held one builder account and no open invitation, read at the change.

This clause's fifty-eighth use: the admission window on every management action. A call to `list_library` or `read_library_entry` from a source past three thousand such calls in the minute is refused 429 `rate_capped` where it was answered. So is a call to `list_context` or `read_context`, or one that names an action with no handler or no action, from a source past six hundred requests in the minute. The admission window's 429 `rate_capped` at the control plane carries a `Retry-After` header, the seconds to the next minute, where it carried none. The summary of `rate_capped` in `schemas/wire_errors.json` moves with it. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-67, which states the window, is not a statement of this document.

This clause's sixtieth use: the admission window of a request that presents a credential on the storage, egress, logging, and push wires. A request there whose presented value resolves to no credential counts in a window its source has for such requests, and past six hundred of them in the minute is refused 429 `rate_capped` where it was answered 401 `authentication_required`. Every token of one end-user session counts in that session's one window, where each counted in its own. A request there in another letter case, or with a route's one trailing slash, counts as the path as written does, where it counted by its source. The summary of `rate_capped` in `schemas/wire_errors.json` moves with it. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-67, which states the window, is not a statement of this document.

This clause's sixty-first use: `submit_feedback`'s answer to a confirmation that names a restricted issue, for a credential that reads the queue on the platform's own space and for any credential on a space the request names. The confirmation is refused 404 `not_found` as one naming no issue is, where it was relayed and linked, for a report the plane filed `field`, `beta`, `person`, or `test`, since the service confirms none of those onto a restricted issue (MAPI-18). The platform then held one builder account, one synthetic account, and no open invitation, read at the change.

This clause's sixty-second use: `submit_feedback`'s `issue` and `outcome` members where a filing's evidence matches a report on a restricted issue, on the platform's own space and on a space the request names, for a report the plane filed `field`, `beta`, `person`, or `test`. The `issue` member carries the unrestricted issue the filing joined or opened, and `outcome` reads `filed` where the filing opens an issue of its own, where it read `linked`. On the platform's own space the `issue` member was null for a credential that does not read the queue; for one that reads it, and on a named space, it was that restricted issue through the projection (MAPI-18). The platform then held one builder account, one synthetic account, and no open invitation, read at the change.

This clause's sixty-third use: `submit_feedback`'s recovered mark, for a credential that reads the queue on the platform's own space and for any credential on a space the request names. The mark is refused 404 `not_found` where the caller's filing under the key did not open the issue, or another reporter's report stands on it, where it was relayed and settled the filing (MAPI-18; the package's XIT-01). The platform then held one builder account, one synthetic account, and no open invitation, read at the change.

This clause's sixty-fourth use: what `relay_issue_act` answers a token below the `owner` level of its `issues` grant. A relayed `follow`, `update`, `comment`, `relate`, or `give_back` naming an issue ITS-L0-05 withholds is refused 404 `issue_refused`, as one naming no issue is, where it answered 200. A relayed `submit`'s or `check`'s `issue` member is null for such an issue, and a relayed `next` answers each member null, where each was as the service gave it. A relayed `arising_from` relation whose target has an issue identifier's form is refused 400 `invalid_request`, where it answered 200. A relayed `submit`'s report carries the origin `field`, where it carried the origin the body named, so one of the kind `question` or `task` is refused 400 `issue_refused`. The platform then held one builder account and no open invitation, read at the change. It is recorded here because ITS-L0-05 is not a statement of this document.

This clause's sixty-fifth use: `submit_manifest`'s `settings` rows on an application with one environment. The answer carries one row per setting, production's, where it also carried a row naming development. No deploy or promote of such an application reads the development scope, and an AI coding tool read that row's `stored: false` as a value to store. An application with both environments is answered both rows, as before. The platform then held one builder account and no open invitation, read at the change. It is recorded here because MAN-14 is not a statement of this document.

This clause's sixty-seventh use: `deploy`'s answered `state` in `schemas/action_payloads.json`, with one request member and one refusal. The answered `state` gains the values `awaiting_command` and `withdrawn`. The request gains the member `withdraw`, which the HTTP action route alone carries, and the response gains `command`, `command_windows`, `expires_at`, and `previous_code`. The refusal catalogue in `schemas/wire_errors.json` gains `deploy_code_refused`. The plane admits the member and answers the values, the members, and the refusal only where it serves the line form of `deploy`. Where it does not, a call naming `withdraw` on the HTTP action route is refused 400 `invalid_request`. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-86, which states the line form and the deploy code, is not a statement of this document.

This clause's sixty-eighth use: `deploy`'s request and its answers in `schemas/action_payloads.json`. `zip_sha256` is marked wire-only beside `withdraw`: the MCP tool declares neither, and a tool call naming either is refused 409 `local_route_required` where it prepared an upload. A call naming none of `zip_sha256`, `artifact`, and `upload` answers the line form, 200 `awaiting_command`, where it drew 400 `zip_sha256_required`, and that row leaves `schemas/wire_errors.json`. The preparing call's answer gains `upload.grant`, and `upload.command` and `upload.command_windows` carry that value where each carried a line. At the preparing form a grant-form bearer resolving to no credential is refused `deploy_code_refused` where it drew `authentication_required`, and a start under a session or token of an upload a later deploy call ended is refused `upload_not_found`. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-86 owns the members and is not a statement of this document.

This clause's sixty-ninth use: `deploy`'s answer to a deploy, by the artifact or the upload form, to an environment that holds no serving version, whose zip names its manifest's health path in no source file. It was answered 202 and started, and is now refused 400 `health_path_unserved` before any write, a row the refusal catalogue in `schemas/wire_errors.json` gains. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-63, which states the check, is not a statement of this document.

This clause's seventieth use: `read_logs`' answer in `schemas/action_payloads.json`. A `container` read that was refused `never_deployed` where the environment names no compute is answered where a failed first deploy's or first promote's health check kept a record, and the answer gains the member `failed_check`. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-59, which owns the behaviour, is not a statement of this document.

This clause's seventy-first use: what `relay_issue_act` answers a `contribute`-level `issues` grant, which the sixty-fourth use recorded for every level below `owner`. A relayed `list` answers a restricted issue it left out, and a relayed `read` answers one it refused 404 `issue_refused`. A relayed `update`, `comment`, `relate`, or `give_back` naming one now reaches the service, once refused 404 `issue_refused`. A relayed `submit`, `check`, or `next` answers such an issue whole, once null, with no lease given back. A relayed `update` whose `fields` name `restricted` with any value but `true` is refused 403 `issues_level_refused`, where it answered 200. A relayed `follow` naming one is still refused 404 `issue_refused` by the service, its report carrying the origin `field`. The platform held 1 builder account and 0 open invitations, read at the change; ITS-L0-05 is not a statement of this document.

This clause's seventy-second use: `deploy`'s answer at its wire preparing form to a deploy code whose minting credential no longer stands, a token revoked or expired or a session ended since the mint. It was admitted where the code's own end was not written, and is now refused 403 `deploy_code_refused`, alike to an unknown code's answer. A code a session minted on the earlier revision is refused so once. The same use has `reinstate_account` refused with the store's failure, the account still suspended, where ending its codes fails, and a session's code answer an `expires_at` no later than its session's expiry. The platform then held one builder account and no open invitation, read at the change. It is recorded here because PLD-L0-86 is not a statement of this document.

This clause's seventy-third use: the lookup limit on the storage, egress, logging, and push wires. A request whose presented value the gateway cache does not hold, and whose lookup cannot start within the wait bound, is refused 503 `credential_lookup_busy` with `Retry-After` of one second, where it was looked up. Through the edge, such a request from a source at its bound for unresolved values is refused 429 `rate_capped` before its lookup, where a value that then resolved was admitted. The `credential_lookup_busy` row and the summary of `rate_capped` in `schemas/wire_errors.json` move with it. The platform then held one builder account, a synthetic test account beside it, and no open invitation, read at the change. It is recorded here because PLD-L0-67, which states the limit, is not a statement of this document.

This clause's seventy-fifth use: the action `rotate_realm_keys`, renamed `revoke_realm_keys` with its MCP tool, because the act revokes the realm's session signing keys (ACS-L0-08). The owner approved the rename. Over the actions route a call naming the old name answers 404 `unknown_action`, its detail naming `revoke_realm_keys`, and the tool surface moves with MCP-08's revision 2. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, `schemas/mcp_surface.json`, and `schemas/wire_errors.json` move with it. CQ-97's three action renames within version 1 are the precedent. The platform then held one builder account and no standing synthetic account, read at the change. It is recorded here because ACS-L0-08, which owns the action, is not a statement of this document.

This clause's seventy-sixth use: the value `redeploy` of the `kind` member of each row in `list_versions`' response, of the `deploy` member in `read_status`'s response, and of `failed_check` in `read_logs`' response in `schemas/action_payloads.json`, renamed `restart`. The versions table's stored value, the stores that read it back, and the mark-redeploy pass keep the name `redeploy`, and the answers write `restart` for it, as the seventeenth use kept `heartbeat_at`. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, and `schemas/mcp_surface.json` move with it. The platform then held one builder account and no standing synthetic account, read at the change. It is recorded here because PLD-L0-63 owns the member and is not a statement of this document.

This clause's seventy-seventh use: the realm member `routes`, renamed `sign_in_methods` in `configure_realm`'s request and answer, in `read_realm`'s and `export_account`'s answers, and in the manifest's `realm` member. The control database's column `realms.routes` keeps its name. `configure_realm`'s request carries MAPI-22's `x-renamed` for `routes`, so a call naming it is refused `invalid_request` naming `sign_in_methods`. A recorded manifest naming `realm.routes` is read under `sign_in_methods`. A submitted one is refused `manifest_invalid` at `/realm/routes`, its detail naming `sign_in_methods` and the one-line edit that renames the member. The descriptions in the payload contract, the tool catalog, the API schema, and the manifest schema move with it. The platform then held one builder account and no standing synthetic account, read at the change. It is recorded here because ACS-L0-07 owns the member and is not a statement of this document.

This clause's seventy-ninth use: the member `after` of `submit_manifest`'s `provisioning` in `schemas/action_payloads.json`. Where the request names `local_run` and development is deployed or a deploy of it is in flight, it says the line revokes the credentials that copy holds. It also says that the line's last re-mint restarts that copy, and that where a deploy of it is still in flight the re-mint's answer names `restart_application` instead. The description in `schemas/action_payloads.json` moves with it. The platform then held two builder accounts and no standing synthetic account, read at the change. It is recorded here because SEC-L0-07 owns the member and is not a statement of this document.

This clause's eightieth use: `list_secrets`' request in `schemas/action_payloads.json`, which took no member and gains two optional ones. `application` narrows the answer to that application's scopes, refused `no_such_application` for an id the account does not own, and `environment`, riding it, to one scope. The descriptions in `schemas/action_payloads.json` and `schemas/mcp_surface.json` move with it. The platform then held two builder accounts and one standing synthetic account, read at the change. It is recorded here because EGW-L0-09 owns the action and is not a statement of this document.

This clause's eighty-first use: `read_counters`' response in `schemas/action_payloads.json` gains an optional member, `detail`, present on an empty answer alone. It says the counters are the application's own count calls, which a request never writes, that the platform's usage is read with `read_usage`, and that a count arrives within a few seconds. The platform then held two builder accounts and one standing synthetic account, read at the change. It is recorded here because system:LGS-L0-15 owns the action and is not a statement of this document.

This clause's eighty-second use: the `realm` object of `submit_manifest`'s response in `schemas/action_payloads.json` gains an optional member, `entra_callback`, present where the manifest's realm member names `entra`. It is the work-account route's redirect address, the realm reads' `callbacks.entra`, which the tenant's app registration lists. The platform then held two builder accounts and one standing synthetic account, read at the change. It is recorded here because ACS-L0-09 owns the route and is not a statement of this document.

This clause's eighty-fourth use: `submit_manifest`'s response in `schemas/action_payloads.json` gains a member, `hostnames`, on every recorded submission. It holds one member per environment the application has, each the hostname `list_applications` names for it, so the receipt says where the application answers before a first deploy. The platform then held three builder accounts and two standing synthetic accounts, read at the change. It is recorded here because PLD-L0-40 owns the hostnames and is not a statement of this document.

This clause's eighty-fifth use: `submit_manifest`'s response in `schemas/action_payloads.json` gains a member, `changed`, on every recorded submission. It is true where the manifest the submission recorded differs from the one recorded before it, or none was, and false where the submission repeats the recorded manifest, so a resubmission says it changed nothing. The platform then held three builder accounts and one standing synthetic account, read at the change.

This clause's eighty-sixth use: an upstream declaration's member `settings`, renamed `sdk_settings` in `declare_upstream`'s request and answer, in `undeclare_upstream`'s and `list_upstreams`' answers, and in an entry of the manifest's `upstreams` member. The control database's column `egress_upstreams.settings` keeps its name. The former name was kept as a deprecated alias on both carriers, as EGW-L0-01 states, and a recorded manifest naming it is read under `sdk_settings`. The descriptions in the payload contract, the tool catalog, and the API schema move with it, and so do those in the manifest schema, the refusal catalog, and the skills catalog. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because EGW-L0-01 owns the member and is not a statement of this document.

This clause's eighty-seventh use: the `halted` member of `halt_environment`'s, `resume_environment`'s, and `read_schedules`' responses in `schemas/action_payloads.json`, and of `read_status`'s environments, reads `false` where the environment runs, where it read `null`. While the environment is halted it still holds the halt's instant and author, so a reader is told an environment is not halted without inferring it from a null. The platform then held three builder accounts and one standing synthetic account, read at the change.

This clause's eighty-eighth use: `read_status`'s request in `schemas/action_payloads.json` gains an optional member, `brief`, true or false. Where it is true, the answer keeps the members that say whether each environment is up and what its last deploy did, and leaves out the rest. Absent or false, the answer is the whole one, unchanged, and a value that is not a boolean is refused `invalid_request`. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because PLD-L0-105 owns the member and is not a statement of this document.

This clause's eighty-ninth use: each entry of the `undeclared` list in `read_status`'s `egress` member, described in `schemas/action_payloads.json`, gains a member, `upstreams`, where the entry's host is the base URL host of an upstream declared for the application. It names those upstreams, sorted, and the entry's remedy then names the gateway route first. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because EGW-L0-17 owns the member and is not a statement of this document.

This clause's use on `submit_manifest`'s response in `schemas/action_payloads.json`: it gains a member, `storage_areas`, where the manifest's `object_storage` entry lists areas. It carries each listed area as `list_storage_areas` answers it, with its outcome, `created` or `unchanged`, and its whole file address. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because OST-L0-01 owns the member and is not a statement of this document.

This clause's use on `submit_manifest`'s response in `schemas/action_payloads.json`: it gains a member, `egress_notice`, where an entry of the manifest's `egress` member admits the host of one of the application's declared upstreams. It names each such host with its upstreams and says a direct call to it carries no key the gateway applies. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because EGW-L0-02 owns the member and is not a statement of this document.

This clause's use on `issue_invitation`'s request `products` items in `schemas/action_payloads.json`: the enum gains `tzteam`, the tzTeam profile's name from the product rename, beside `blueprint`, its earlier spelling, which the plane reads as `tzteam` through the rename's window (ACB-L0-76; ACB-L0-77). The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because ACB-L0-77 owns the member and is not a statement of this document.

This clause's use on `submit_manifest`'s response in `schemas/action_payloads.json`: each row of its `schedules` gains a member, `cron_preview`. It holds up to three instants the row's expression yields after the submission, as `read_schedules` answers them, and null on a row the submission ended. The descriptions in `schemas/action_payloads.json` and `schemas/skills.json` move with it. The platform then held two builder accounts that each held a live application, synthetic accounts excluded, read at the change. It is recorded here because SCH-L0-07 owns the member and is not a statement of this document.

This clause's use on nine actions, each merged with its MCP tool into one of five successors that take a mode member (`declare_storage_area`, `declare_upstream`, `set_end_user_standing`, `invitation`, and `test_end_users`), the tool surface moving with MCP-08's revision 5. `undeclare_storage_area` and `undeclare_upstream` are now `declare_storage_area` and `declare_upstream` with `remove` true. `revoke_end_user` and `reinstate_end_user` are now `set_end_user_standing` with `standing` `suspended` or `active`. `issue_invitation` and `revoke_invitation` are now `invitation` with `act` `issue` or `revoke`. `create_test_end_users` and `delete_test_end_users` are now `test_end_users` with `act` `create` or `delete`. `withdraw_test_end_users`, merged into the act `withdraw`, retired with that act at MCP-08's revision 8, and it answers `unknown_action` naming no successor (ACS-L0-21). The owner approved the merges.

This clause's use for the owner's approved app sign-in renames under the addresses plan's decision 11 (family:Q-313): `configure_realm` becomes `configure_app_sign_in`, `check_realm` becomes `check_app_sign_in`, `read_realm` becomes `read_app_sign_in`, and `revoke_realm_keys` becomes `revoke_app_sign_in_keys`. Each rename changes the action, its REST address, its tool and its first-party callers together, a hard cutover within version 1 without an alias. Each old action name answers 404 `unknown_action` naming its successor, on the actions route and as a tool's error result.

This clause's use on `deploy`'s preparing answer in `schemas/action_payloads.json`: its `upload` leaves out `command` and `command_windows`, which carried the upload grant's value beside `grant` since the sixty-eighth use, and `grant` carries that value alone. The command floor refuses every command that read either member (PLD-L0-109). The platform then held 6 builder accounts that each held a live application, synthetic accounts excluded, read on production in the release dry run at the change. It is recorded here because PLD-L0-86 and OST-L0-08 own the members and are not statements of this document.

This clause's use on `reassert_compute` removes the operator action within contract version 1 at the owner's approval by name. Its old name answers `unknown_action` on the actions route, naming no successor, and its tool leaves the operators' MCP address under MCP-08's revision move. Every estate uses the usage form, so the walk can only compare equal terms and record unchanged compute.

MAPI-03 (decided): A credential is a bearer credential presented per request, never carried in a URL, and is one of four kinds: the **session credential**, the **minted token**, the **platform credential**, and **no credential**. Beside them, the third and eighth paragraphs admit three short-lived grants, each on the requests its act admits and nothing else. The session credential is minted by a present person's sign-in and takes three forms. The first is the bearer session the OAuth flow issues (MCP-02's binding). The second is the browser credential the approval page and the operator's CSV download under `/dashboard` run under (MAPI-05; WEB-L0-16), no credential on the wire. The third is the browser session, the API cookie of the browser leg (WEB-L0-16), which the cookie address alone admits as a wire credential, under a guard of its own (MAPI-10; CQ-283), and under which the signed-in site's pages run their acts (CQ-63).

The **minted token** of API-L0-05 is created by a session through `mint_token` and bounded at its minting to the account or to one application (API-L0-17; MAPI-14). The one exception is the support read token, which the support consent route mints under the support cookie (WEB-L0-16; MAPI-29). The CI credential and the application-bounded builder credential are this one kind under its two scopes. The **platform credential** of SEC-L0-07 is admitted here by `read_account` alone. The fourth kind is **no credential**, the kind a marked row runs as for a caller whose account does not act (MAPI-11). It is also the kind `search_documentation`'s signed-out search answers, for a request presenting no bearer credential (CTX-10).

A credential the platform issues for a data-plane act alone is refused by name on every action of this contract, but for the start of an upload that `deploy` admits under that upload's own grant (OST-L0-08; PLD-L0-86; CQ-270). Those are the end-user credential the accounts service issues, the transfer grant object storage mints, and the egress key the platform mints for one upstream of one compute (SEC-L0-18), each stated by its own surface. The secret grant, which the platform mints for one custody act, is admitted on `store_secret` over the wire for the requests its act admits, and on nothing else (SEC-L0-19). Every other action, and a request the grant's act does not admit, refuses it `secret_grant_not_admitted`, but for the rules the sixth paragraph names. A request it admits is refused `secret_grant_spent` once the grant is spent, and `secret_grant_expired` once it has expired unspent.

A bearer of a grant's form that resolves to no credential is refused `authentication_required`, with the challenge MCP-02 states for a presented credential that resolves to nothing. Such a bearer is a grant never minted, a grant whose record the platform has removed after its expiry or with its application or account, or a value that differs from the one minted. No record answers, so the refusal names no kind of grant. Its detail says that the platform serves no grant of that value, and that a grant lasts minutes and serves the one act its mint names. It names both ways to a fresh grant: a tool call whose answer carried the grant is made again and the fresh command it answers is run, and an application that requested the grant requests another.

The browser session is read only from a same-origin JSON post that presents no `Authorization` header and is verified as the dashboard guard verifies its cookie. It is admitted on a row naming both `bearer` and `browser_session`, or `browser_call` alone; the approval row naming `browser_session` alone stays on its own page (MAPI-05). Every other row refuses it `authentication_required` before any store read. A state-changing action under it past the freshness window WEB-L0-16 states is refused `fresh_authentication_required`. It runs on the `browser` surface, which is answered no credential value but `mint_upload_grant`'s upload grant (SEC-L0-07; OST-L0-08). Every other surface, `/mcp` and the data-plane surfaces among them, keeps resolving the `Authorization` header alone. The authority tiers bind per credential (API-L0-06): what a credential may do is its grant, the destructive class is deny-until-granted, and no client kind carries a laxer tier than any other (API-L0-11).

This paragraph names the rules that answer a request presenting a secret grant ahead of the third paragraph's refusal. The approval action reads no credential on the actions routes and refuses any bearer `browser_session_required` (MAPI-05). A page's own action, whose row names `browser_call` alone, refuses any `Authorization` header with that name before reading a credential (MAPI-03). An action switched off reads the grant and refuses by its switch's name (MAPI-16). Neither admits the grant to anything.

A secret grant whose act is `provision` is admitted on `store_secret` with `replace: true` over the wire for its application's two platform-minted names at the development scope, each once (SEC-L0-19). Its bearer is the verifier the turnzero command keeps, read as the next paragraph states. The request names no value and carries no member beyond `replace: true`, the name, the application, the environment, and `code_verifier`, which a grant bound to a challenge requires (SEC-L0-19). A second re-mint of a name is refused `secret_grant_spent`. `submit_manifest` takes the member `local_run`, which asks for that grant's line: `true` alone, on the MCP surface and over the wire under a bearer credential. Any other value, and the member on a surface that is answered no credential, is refused `invalid_request` with nothing recorded. Beside it a submission names `code_challenge`, which binds the grant to that verifier, and without it no grant is minted.

This paragraph adds the token code to the third paragraph's short-lived grants. A token code is admitted once, at `mint_token`'s wire exchange form alone. There a code the plane does not admit, and a bearer of a grant's form that resolves to no credential, are refused as MAPI-23 states, in place of the fourth paragraph's refusal. On every other request a token code is answered as the fourth paragraph states, unspent (MAPI-23). The seventh paragraph's verifier is read at `store_secret` with `replace: true` over the wire alone, where the guard hands the dispatcher a verifier-form bearer with no credential prefix that no store answers. The dispatcher finds the grant by the bearer's S256 challenge and the request's `application`, refuses a suspended owner's grant `account_suspended`, and refuses a claim that finds none `authentication_required` with the fourth paragraph's detail and no challenge. Elsewhere the verifier is a bearer that resolves to nothing.

This paragraph states the one exception to the first paragraph's rule that no credential is carried in a URL. The computer login page (WEB-L0-25) sends the token code it minted to the turnzero command's listener on the person's own computer, in the query of `http://127.0.0.1:<port>/?code=<code>&state=<state>`. The code is one-time, lives minutes, mints nothing without the verifier that computer alone holds, and is sent to the loopback address alone. The address stands in the browser's history, the one residual, which the record accepts. Every other credential and grant stays off every URL.

This paragraph and the two after it add the signed form of a product token to the minted token's kind. There is one form for every row of the plane's product table (MCP-02), the `tzmesh` row's as it stood and the `tztrack` row's beside it. The token a product's exchange mints (MCP-02; MAPI-14) carries its claims and the plane's Ed25519 signature in its value. The value is the prefix `turnzero_cloud_tok_<product>1.`, a base64url JSON payload, a dot, and the 64-byte signature over the prefix and the payload. The prefix carries the product's name and its contract's generation, `turnzero_cloud_tok_tzmesh1.` for `tzmesh` and `turnzero_cloud_tok_tztrack1.` for `tztrack`. The prefix's `tzmesh1` and `tztrack1` each name that product's contract's first generation; system:XTX-22 states what changes take a later one and in what order for `tzmesh`, and system:XIT-24 for `tztrack`, on the same rule.

The payload names `kid`, the signing key; `iss`, the plane's origin; `aud`, the product's resource; `sub`, the account; `jti`, the token's identity; `level`; `label`; `iat`, the mint; and `exp`, its expiry, each instant in seconds. The expiry is 180 days after the mint for an exchange's token, and for `mint_token`'s the days the mint named, 180 where it named none (MAPI-14). The `tzmesh` service reads `level` and bounds no call by it (system:XTX-02). The token the `tzmesh` site's own sign-in client's code exchanges for carries an `exp` one minute after the mint (MCP-02). Each product's service refuses a token whose `exp` has passed, and the person signs in or mints again; no refresh renews it (API-L0-05).

The key is the realm key service's under the product's reserved realm name, `tzmesh` or `tztrack` (ACS-L0-05's keys), one key set per product, each published as MCP-02 states. A retired key stands one token life plus a day, so every token signed under it verifies until its own expiry unless the key is revoked (MAPI-09). On this plane the value resolves by its hash, as every minted token's does; each product's service verifies it by signature with no call to the plane. A `tzmesh` or `tztrack` token `mint_token` mints takes the same signed form at its code's exchange, signed by the accounts service under a single-use ticket (MAPI-23), since the management process holds no signing key (SEC-L0-07). The tzTrack resource's exchange answers the signed `tztrack` token (MCP-02), and `mint_token`'s is served as MAPI-23 states.

This paragraph adds the front's token to the one above, as an exception to its hash rule. The token the MCP server's front mints for a connection it serves (MCP-14) takes the same signed form. It has no row here, resolves to nothing here, and is presented at its product's door alone.

This paragraph adds one optional claim to the payload of a `tzmesh` token's signed form. A token a builder's application's code exchanges for (MCP-02) carries `application_sign_in`, written only as `true`, the mark of a sign-in through an application, and every other `tzmesh` token omits it. A reader takes `false` as it takes absence. The claim is no application scope of the second paragraph's, and the `tzmesh` service reads it as system:XTX-22 and system:XTX-02 state.

This paragraph adds a second such claim. A `tzmesh` token of an operator's synthetic test account (ACB-L0-79) carries `synthetic`, written only as `true`, and every other token omits it, an account seeded with an access link among them (ACB-L0-87). The erasure walk's token omits it too, since no join or send admits that token. The plane reads the mark from the account's record at the mint, and no request can ask for it. A reader takes `false` as it takes absence, and the `tzmesh` service reads it as system:XTX-22 and system:XTX-05 state.

This paragraph adds a third such claim. A `tzmesh` token of an account holding an identity in the operator set (MAPI-09) carries `operator`, written only as `true`, and every other token omits it. The erasure walk's token omits it too. The plane reads the account's bound identities against the operator set at the mint, and no request can ask for the mark. A reader takes `false` as it takes absence, and the `tzmesh` service reads it as system:XTX-22 states.

This paragraph adds two optional claims to the payload of a product token's signed form, the MCP front's approval marks (MCP-14; MCP-07). `describe`, written only as `true`, marks the token the front presents to read what a destructive door call would destroy. `pending_action`, the plane's pending action's identity, marks the token the executor presents for the approved act. The front mints each for one call, living five minutes, held in no row; no exchange and no `mint_token` writes either. A door declares on its served row which marks it honours, admits a destructive act under `pending_action` alone, and reads a token carrying neither by its own rule. Whether a mark moves a product's generation is system:XTX-22's question for `tzmesh` and system:XIT-24's for `tztrack`.

This paragraph states one exception to the fifth paragraph, outside the actions routes. The six posts of the Questions page under `/api/v1/support/` are the chat id, the consent, its end, the chat's message, the turn read, and the answer's rating (MAPI-32). They read the support cookie (WEB-L0-16), path-scoped to `/api/v1/support/`, on a same-origin JSON post that presents no `Authorization` header, verified as the site gate verifies the site cookie, with no freshness window (MAPI-29). The site cookie alone signs no chat and admits neither the consent nor its end (CQ-283). The message, the turn read, and the rating reach less than the other three. They resolve the cookie's account only to tell the support application which account a signed-in chat belongs to, and they mint nothing. A request with no admitted cookie runs as a signed-out chat's rather than being refused.

This paragraph states the one credential value the fifth paragraph's `browser` surface is answered. A cookie call of `mint_upload_grant` is answered its upload grant (OST-L0-08), whose copy reaches one write of one named file within the grant's configured lifetime, five minutes by default (OST-L0-08), and no account act. The application page uses it at once as the bearer of that one `PUT`, sent in the `Authorization` header and in no URL, and shows it nowhere (WEB-L0-17). Every other credential value stays off the `browser` surface (CQ-283).

The tzMesh site's token route is a further exception to the fifth paragraph's header-only rule (ACS-L0-18). It reads its own path-scoped cookie and answers a signed `tzmesh` token that lives 300 seconds, with no token-store row. The page holds it in memory alone. It carries `person: true`; `site_session`, an opaque HMAC reference to the browser session; and `fresh: true` where that session signed in within eight hours of the mint. A false or empty member is absent. The reference is neither the session row's identifier nor its secret. The service reads these claims under system:XTX-22.

A row naming `browser_call` alone is a page's own act. Only an API cookie call at the cookie address reaches its handler (MAPI-10). It refuses an `Authorization` header 403 `browser_session_required`, even beside a cookie, and reads no bearer. Without an admitted cookie call it refuses 401 `authentication_required`, with no bearer challenge. Its admission window is counted once before these refusals (PLD-L0-67).

The credential of an admitted API cookie call carries the generation the verified cookie named and the one admission read held to the session row (ACS-L0-18; ACS-L0-25). A suspended account is refused `account_suspended`; WEB-L0-16's freshness rule governs a state-changing action. The approval page's credential and the executor's carry no cookie generation.

MAPI-04 (decided): Every action carries its tier in the enumeration — observe, reversible, destructive — and the tier governs the call's shape. An observe action changes nothing and may be repeated freely. A reversible action completes in the call that made it or, where its statement says so — `run_schedule`, `deploy`, `promote`, `roll_back`, `restart_application`, and two staff purges —, records the act and answers at once, its outcome read through the observe act that statement names. Of these, `run_schedule` and the four acts MAPI-04's paragraph Held acts names answer at once unless the request's `wait_seconds` holds the answer, as that paragraph states. A retried reversible call is a second call of the action, what a repeat does being each action's own statement's to say.

A destructive action accepts a client-supplied request identity, the optional `request_id` member of its request, so a retried request lands on the same pending action once rather than a second one, because the callers are AI coding tools, and retry-on-timeout is how they behave. MAPI-05 states the match.

No reversible request schema in `schemas/action_payloads.json` carries a request identity the plane ignores. The twelve that did, under the names they then had — `mint_token`, `revoke_token`, `configure_app_sign_in`, `revoke_end_user`, `reinstate_end_user`, `issue_invitation`, `revoke_invitation`, `set_plan`, and four of staff's — lost the member as MAPI-02's second paragraph records, and a call naming it is refused as MAPI-22 states.

`run_schedule`'s required `request_id`, which its own code reads, is not within that removal, what its repeat answers being that action's own statement's to say. The optional `request_id` of the staff seed and purge of synthetic accounts is a member of the same kind, read by their code, each repeat answering as MAPI-16 states.

**Held reads.** This paragraph qualifies the first paragraph's clause that an act answered at once has its outcome read through an observe act. `read_status`, `read_schedules`, and `read_usage` take optional `wait_seconds`, an integer from 1 to 45. The payload schema states the range; the MCP argument layer and wire handler hold it (MAPI-02). Status waits for the application's version-history rows still `deploying` (PLD-L0-63) and uploads in progress on its deploy target (PLD-L0-86); SCH-L0-06 names the schedule wait. Those two poll every two seconds until nothing is in flight or MAPI-04's paragraph Wait deadline's bound, then answer `settled` from their final read and `waited_ms`. Usage holds until that bound, composes its answer from reads after the hold, and adds `waited_ms` without `settled`. It has no in-flight condition that ends the hold early.

**Read bounds.** This paragraph bounds the held reads above. Status and schedule compose each answer from their last store read; every early end answers `settled` from that read. Either answers at once where nothing is in flight. A process holds at most one read per application, one usage read per account, and fifty in all; a read beyond either applicable bound answers at once. The deploy command's progress read holds one place per upload, never an application's, within the fifty and its route's 25 seconds (PLD-L0-86). A held read answers at once when its process begins shutting down, before the listener closes, and ends when the caller's connection closes. An answer of an act of MAPI-04's paragraph Held acts that did not settle names the wait in its `detail`; `run_schedule` without one names both waits by their actions.

**Held acts.** This paragraph extends MAPI-04's paragraph Held reads' held read to the acts that start a version-history row, `deploy` in each of its starting forms, `deploy_files` (API-L0-25), `promote`, `roll_back`, and `restart_application` (PLD-L0-63; PLD-L0-84; PLD-L0-86), and to `run_schedule`. Each takes the same `wait_seconds` and holds its answer until the row it started ends, answering as PLD-L0-63 states, or for `run_schedule` until its run ends (SCH-L0-06). Each hold is a held read, polling as MAPI-04's paragraph Held reads states and bounded as MAPI-04's paragraph Read bounds states. So an act's hold takes its application's one held place, and a concurrent held read of that application on the same process answers at once. An act that finds the place taken answers at once, its `settled` from its own row or run. `deploy_command` and `deploy`'s preparing call start no row: each holds nothing and carries the member into its `next`, 45 where absent.

**Wait deadline.** This paragraph bounds every wait this statement states by the call's time. A held read or act stops polling once `wait_seconds` have passed since its credential was admitted, so the time an act spends before its hold, a slow artifact read among them, is spent from its wait. A `container` read's wait stops at the earlier of its `wait_seconds` and forty seconds, so a value above 40 is held 40. The hold adds nothing past that point but the final read's time, so an answer whose work before the hold took less than its wait stays under fifty seconds. On the wire, a value outside 1 to 45 is refused `invalid_request` by the handler, its detail naming 45 as the most the member admits, for the four reads, the held acts, and `deploy_command` alike. Over MCP the argument layer refuses it first, its text naming the same bound.

This paragraph qualifies the paragraph above's hold for a deploy or a promote whose row ended `deployed`. Its answer also spends the server-error count's read, which its bound holds to three seconds (PLD-L0-63), so it too stays under fifty seconds where its work before the hold took less than its wait.

**Log waits.** This paragraph extends MAPI-04's paragraph Held reads' held read to the log read `read_logs` on a store source. It takes the same `wait_seconds` and holds its answer while the read with the call's own filters finds no entry, answering from a fresh read with `waited_ms` and no `settled`. Its hold is a held read of this statement, polling, bounded, and placed as MAPI-04's paragraphs Held reads, Read bounds and Wait deadline state, and an empty answer whose wait found the place taken says so in its `detail`. A `container` read carrying the member holds as MAPI-04's paragraph Console follow states and never polls, because each console read is a query to the provider.

**Wait constants.** This paragraph names the one home of the waits' figures. One set of code constants holds the range, the poll, the polling stop, and the cap for the reads and the held acts, and the `container` wait's stop and its cap on followed consoles beside them. The deploy command's progress read takes its stop from its route (PLD-L0-86).

**Retry checks.** This paragraph qualifies MAPI-04's paragraph Held acts' held acts and the first paragraph's retried call. An answer to one of those acts that is not the platform's, an edge's error page or a closed connection among them, says nothing about whether the act was made. The server's instructions (MCP-05) and each act's description say so, and send the caller to the act's status read first, `read_status`, or `read_schedules` for `run_schedule`. One of the four acts started only where its environment's `deploy` member names the kind of row the act starts, with a `started_at` later than the call. A deploy's upload that `pending_upload` still names was not started, and its `retry` starts it. Each of the four acts is repeated only where that read shows no start, and `run_schedule` only with the same `request_id`, as its own statement says. What a repeat does stays each act's statement's to say.

**Console follow.** This paragraph extends MAPI-04's paragraph Log waits' wait to a `container` read, which holds by following its console instead of polling. Where the operator's `console_live_tail` is 1 (PLD-L0-137), the read takes the application's one held place first. It then follows the console of each running instance of the serving compute and of a deploy's candidate, three at most, or of a pod's newest instance, beside the console store's read on the container grain. It holds its answer until a followed or stored line the call's filters admit, stamped at or after its `since`, is read, or until MAPI-04's paragraph Wait deadline's stop. It answers as a `container` read does, every line its follows read merged in, with `waited_ms` and no `settled`. Where nothing runs, or every follow has closed, it lists the instances once more ten seconds later and follows a newcomer, never listing a third time.

**Follow bounds.** This paragraph bounds MAPI-04's paragraph Console follow's wait. A process holds at most nine followed consoles beside the fifty held reads, and a wait following none counts one. A wait that finds the switch at 0, the place taken, or the process's nine follows held answers at once as an ordinary `container` read, its `detail` naming which. On the container grain, each listing reads the management API's remaining reads from its first answer; below fifty the wait answers at once with the lines read so far, and it lists a second time only where at least one hundred remain. A deploy, a promote, and a roll back do not read that figure, so fifty is what a burst of waits leaves them. The wait ends on the caller's close and at the process's shutdown, and each end closes every follow.

This paragraph qualifies MAPI-04's paragraph Console follow's hold on the pod grain. A pod wait that finds no pod it has not already followed at its one more listing answers at once with the lines read so far, its `detail` saying no pod ran. A pod wait whose last follow closes after its one more listing, as when the pod's process exits, answers at once with the lines read so far and no sentence on how it ended, since a pod's console ends with the pod.

This paragraph qualifies MAPI-04's paragraphs Console follow and Follow bounds for a `container` read answered from a failed check's kept lines (PLD-L0-59). That read reads the version row, not a console, so it takes no held place and answers at once, its `detail` saying so.

**Schedule console.** This paragraph qualifies MAPI-04's paragraph Wait deadline's final read for `run_schedule`. Its settled answer's console read, which SCH-L0-06 states, follows the final read, inside the same fifty seconds. It is not made once the process has begun its shutdown or the caller's connection has closed, MAPI-04's paragraph Read bounds' ends. A read in flight when the shutdown begins ends by its own eight-second bound, inside the shutdown's close budget.

**Wait range.** This paragraph qualifies MAPI-04's paragraph Held reads' range and MAPI-04's paragraph Wait deadline's refusal. The range stops at 45 so that a held answer, its final read included, reaches the caller inside the sixty-second request timeout the MCP SDK's client sets by default, which many tools keep. A longer wait repeats a read, including the `next` call an act supplies. A read returns once its condition is met; `read_logs` waits for entries to arrive or settle, and `read_usage` waits to its bound. The MCP server's instructions state this reason once and tell a caller with a shorter tool timeout to pass fewer seconds, including on a returned `next` call. The refusal's detail adds the same reason and the repeated read. The deploy command waits through its own progress read, never through this member (PLD-L0-86).

This paragraph qualifies the first paragraph's clause that a reversible action completes in the call, for `halt_environment` on a pod environment. Its halt completes in the call: the halt is written, and the hostname is refused within the routers' resolve interval. The pod's stop follows the answer, after the wait PLD-L0-41 states. It is read through `read_status`, whose `compute_state` reads `Running` while the pod holds a ready replica and `Idle` once it holds none.

This paragraph extends MAPI-04's paragraph Held acts' held act to `store_secret` with `replace: true`, whose `wait_seconds` rides `restart` true and holds the answer until the restart that member starts ends (MAN-14). The hold is that restart's held act, polling, bounded, and placed as this statement states for `restart_application`, and the answer gives the restart's end in its `restart` member, never in its own `state`.

**Request settling.** This paragraph qualifies the read_logs paragraph's hold for a read by the router's request id. A held `read_logs` whose field is `request_id`, with no source or `all`, settles. Past its first entry it waits until the `router` source and the `app` source have each answered. Otherwise it ends at the first poll that finds no new entry once three seconds have passed since a poll first found one, longer than the logging client's two-second flush. Every other held `read_logs` answers once an entry arrives.

MAPI-24 (decided): A call an answer leaves its caller is named in `next` where the answer's owning statement gives it. A call is left where the act's effect, or the caller's reading of the act's end, waits on it: a call that applies what the act, or its line, wrote, one a later act refuses without, or the read of work after the answer. Where its owner gives the call, the answer carries it as `next`, an object of `action` and `arguments` the platform fills in whole, made as given (PLD-L0-63; PLD-L0-84; PLD-L0-86; SCH-L0-06; MAN-14; MAPI-16; MAPI-21).

This paragraph qualifies the paragraph above for an action whose answer may leave several such calls. Its `next` is always an array of those objects, one per call, in the order to make them, so a caller never branches on the member's type. An action whose answer leaves at most one call carries the object alone. An answer that leaves no call carries no `next`.

This paragraph bounds the first paragraph. An answer carries no `next` for a person's step, as a destructive action's approval is (MAPI-05). It carries none for a call only some callers want, as a resubmission naming `local_run` is, since no answer knows whether a local run is wanted (SEC-L0-07). Its `detail` names such a step where the detail's budget keeps the line (PLD-L0-39), as it names advice on a next act after a complete one. A call that follows a line applies only where the line did its act; where a line reports that nothing started, its printed refusal is the way on, and the answer's `next` does not apply (PLD-L0-86; PLD-L0-94).

This paragraph extends the first paragraph to a refusal. A refusal whose remedy is one exact call may carry `next` naming that call, in the second paragraph's form for one call, the object alone. It is filled in whole except a secret's value, which no `next` carries. The refusal's detail stays as its owner states it, and its row of `schemas/wire_errors.json` declares the member (MAPI-15). The first such refusal is `setting_secret_missing`: it carries the `store_secret` call for the target scope, naming the bound name, the application, and the environment the deploy or promote targets, and no value (MAN-14). That call is the remedy that keeps the manifest as submitted, and the refusal's detail still names the other way, removing the binding, so the third paragraph's bound for a call only some callers want does not reach it.

This paragraph names the members that share the name or the form. A member named `next` inside another member keeps its own form: `provisioning.next` and `download.next` are sentences. A refused start's `retry`, which `read_status`'s `pending_upload` carries, is a call of the same form under its own name (MAPI-04; PLD-L0-86). `check_deploy`'s `without_command` is a call of the same form that its caller completes with its files (PLD-L0-107). It is no `next`, since the platform cannot fill it in whole, so the third paragraph's bound does not reach it, and `detail` still names the route. `store_secret` with `replace: true`'s `restart` member carries in its own `next` a call of the same form. That call is the one the answer's top-level `next` names where both stand, or the `read_status` call that reads a restart it started that the request's `wait_seconds` did not see end (MAN-14).

MAPI-05 (decided): The pending action is a resource of this contract: a destructive action's request creates one, and its record carries Turn Zero Cloud's own description of what will be destroyed. The one action that completes it — approval — is callable only by a signed-in person's browser session (WEB-L0-13), a client restriction the enumeration states and the suite refuses violations of. The requesting credential reads the record and its outcome; nothing but the browser approves. The request's `request_id` member is the pending action's request identity (MAPI-04): a string the caller chooses, matched by equality and never interpreted.

A second request carrying the same `request_id`, from the same requesting account, for the same action, while the earlier record is live (approved or executing, or requested and not past its expiry), answers that record, its approval link included, and creates no second one. A record that is no longer live — completed, failed, declined, expired, or requested and past its expiry — matches nothing, so the same `request_id` then starts a new pending action. A request carrying no `request_id` is matched to no earlier request, each such call creating its own pending action.

The match runs after the destructive request has passed the credential gates and its description has been produced, so a request that refuses by name refuses on every repeat and matches nothing. The subject named by a repeat is not compared, the caller's identity being the caller's to keep distinct. The durable store holds the match as one partial unique index over requesting account, action, and request identity on the live states. A test in the platform's suite holds the match, the per-account separation, the release after a decline, the unmatched case, and the lapsed case.

A destructive door row the MCP front lists creates a pending action of this resource too (MCP-14; MCP-07). Its action is the row's prefixed name, its subject the product and the door tool, and its stored input the product, the tool, the arguments, and the token's label. Its description is the product's own first-party reading (API-L0-07), in place of Turn Zero Cloud's own description for a plane row. The requesting credential reads it as any other. Its request identity is the plane's own, since a door call carries no `request_id` the plane reads, so each such call creates its own pending action.

`read_approval_status` with `brief: true` answers the record without its `description`, and its `outcome` with only its short values: booleans, numbers, nulls, and texts of at most 100 characters, such as `deleted` or a refusal's name. A caller polling for the person's decision reads that form, and the whole read answers the receipts.

MAPI-06 (decided): Every action writes the append-only operational record — actor, credential, action, subject, outcome, any confirmation, and, on a dispatched call's row, the reference the call's answer carries (API-L0-19) — from the first action of C2 onward. **The credential is recorded as itself and not only as its kind**: its kind always, and its own identity wherever it has one, which an unattended token does and a browser session does not (API-L0-05; MAPI-03). Without that, every act a credential performs is indistinguishable from every other act of the account that minted it, and an automated publish running unattended reads in the record as the person doing it by hand. Telling the two apart is the one thing the record exists to be able to answer.

The record is readable and exportable by no served surface: it exists so that the platform's own operation has a durable account of what was done, not so that a customer or an operator can query one. Three readers inside the platform stand. Two join on the record's reference column under an account and near the call's time, because the reference is not unique across the record's retention (API-L0-19). The third reads a named action's completed calls inside a window of time. No served surface reads the record, and no export carries it.

The daily pass's feedback step answers two bits for a report's quoted reference, whether such a row stands and whether it records a refusal, and never a row, and marks the report at the issue service (PLD-L0-67). A filing's stamp reads the action, the outcome, the build, and the code site of the filer's own call, or of a call of a batch its token seeded (MAPI-18). The same step's exposure read answers each completed call of a fixed issue's action with its account, reference, instant, and build (PLD-L0-67).

Recording is never deferred to a reader's arrival, because a record that begins when a reader arrives is not a record, and it is buffered for at most one second. Every action's record is appended to the plane's meter buffer as the action completes and flushed to the `action_records` table within one second or two hundred rows, after the caller is answered. So a process end loses at most one flush interval of records, and no reader is ever the trigger (CQ-36). The table is monthly range partitions dropped after twenty-five months, every row carrying the environment.

A row the store refuses loses that row alone. A flush statement that fails twice is written again one row to a statement, and the rows the store refuses alone are dropped and reported once for the table in a flush, together with the table and their count. Two cases drop a failed statement's rows whole, reported, with no row written alone. One is a statement whose connection dropped after it was sent, because the store may already hold its rows. The other is a store the plane could not reach across its failover window or within a checkout, because a row-by-row write would wait that out once for each row (PLD-L0-67). A store lost inside the row-by-row write ends it, and the row it failed on and the rows not yet written are dropped and reported together, with their count, in a report apart from the rows refused alone.

The same buffer carries a gateway's usage rows, so calls a gateway answers from its held entries through a control-database outage (PLD-L0-67) may go uncounted, and these reports are the one reading of how many.

The logging feature package (Q-226) owns the operational record once Turn Zero Cloud consumes it and the record writes through (issue #588), and this statement is re-parented to it then.

MAPI-07 (decided): A manifest change is the `submit_manifest` action on the application resource: validated against the manifest contract with refusals naming the failing path (MAN-12), applied as one deliberate action, recorded like every action (MAPI-06). Nothing else in the contract widens an application's declared reach, which is what ADM-L0-07's no-side-effect promise means here.

MAPI-08 (decided): The MCP tools are these actions, one to one and name for name: every tool of `schemas/mcp_surface.json` is an action of `schemas/management_api.json` at the same tier. Every action callable by AI clients is a tool. The approval action and a page's own actions, whose rows admit no bearer, are absent from the tool surface (MAPI-05; MAPI-03). The correspondence covers the call and not only the name: a tool declares the arguments its action accepts, derived from that action's request schema in `schemas/action_payloads.json`, so what a caller can express over the wire it can express as a tool.

One exception, on answers, owned by SEC-L0-07: an application's standing credential value is answered on the wire surface alone. So `submit_manifest` as a tool withholds its two value members and states `credentials: withheld`, and the two development re-mints of `store_secret` with `replace: true` are refused as a tool, `local_route_required`, and answered on the wire. Those tools declare the same arguments as their actions, save a member marked `x-wire-only`, and the difference is in the answer alone. An exception to the listing rule, owned by MAPI-16: the two rows the enumeration marks `switch: synthetic_estate` are listed as tools while the synthetic estate's posture, the control plane's setting `SYNTHETIC_ESTATE` (MAPI-16), is not `off`. They are unlisted while it is `off`, their wire routes standing and refusing `synthetic_estate_disabled` by name.

An exception to the argument rule, owned by SCRT-L0-02 and CHI-L0-08 for a secret's value, by PLD-L0-86 for `deploy`'s members, by MAPI-23 for `mint_token`'s, and by ACS-L0-21 for `sign_in_test_end_user`'s: a tool declares no request member marked `x-wire-only`, which the HTTP action route alone carries. Those members are five the turnzero command alone names: `deploy`'s `zip_sha256`, `mint_token`'s `code_verifier` and `mint`, `store_secret` with `replace: true`'s `code_verifier` under a `provision` grant, and `sign_in_test_end_user`'s `delivery`.

`store_secret`'s tool declares `value`, with or without `replace: true`, under SCRT-L0-02's one exception: a value the person already put in the conversation, which the transcript holds already. The plane writes it as the HTTP action route does, with the same bounds, a name that stands at its scope re-supplied as there, and never echoes or logs it. A value on disk goes through the line, which never shows it to the assistant. A `store_secret` tool call naming no value is the preparing form, save one naming `generate`, the creating write SEC-L0-20 states. The platform-minted names keep the answers above.

A written replacement whose tool call carried `restart` or `wait_seconds`, which its tool does not take, starts no restart, and its answer's `note` says so.

This paragraph adds two members to that exception, owned by MAN-14, SEC-L0-19 refusing each under a grant: `store_secret` with `replace: true`'s `restart`, which restarts a running copy, and its `wait_seconds`, which holds the answer for that restart. Each acts on the HTTP action route alone and on no tool call, so the tool declares neither.

`create_application`'s `kind` carries no `x-wire-only` mark. Its tool declares the optional member, `server` or `serverless`, and reads it as the HTTP action route does. The turnzero command does not send it; it is outside the five members that command alone names.

A `store_secret` call that names a name of the caller's own and no `value` or `generate` is the preparing form (SEC-L0-19). It is answered through the tool and on the HTTP action route under the caller's own bearer credential, and under the browser session it is refused `invalid_request`. It writes nothing, mints a secret grant for the one write it names, and answers `state` as `awaiting_value`, `expires_at`, and the line that makes that write in its four forms (PLD-L0-94). A rotation's answer carries `next`, the `restart_application` call to make, where MAN-14 names one. The call may name `value_file`, the path the line reads the value from, which the tools declare, and a call naming it beside `value` is refused `invalid_request`.

A `store_secret` call naming `generate` is no preparing form: it writes in the call on every surface and answers no value (SEC-L0-20). The `store_secret` tool declares `generate`, which carries no value, and refuses it beside `replace: true`. A tool call that carried a `value` and named `generate` is refused as SEC-L0-20 states, not answered the preparing form.

`code_verifier` is the code form's one member on `mint_token`, and `mint` the held form's, each read on the HTTP action route. A `mint_token` call naming either anywhere else is refused as MAPI-23 states, the MCP surface's refusal read through the mark as `deploy`'s handler reads `zip_sha256`.

`delivery` is the one member of `sign_in_test_end_user` the turnzero command's `session` sends, read on the HTTP action route, and a call naming it anywhere else is refused `local_route_required` as ACS-L0-21 states, the MCP surface's refusal read through the mark as `deploy`'s handler reads `zip_sha256`. Test end user actions have no statement of this document, ACS-L0-21 owning them.

The suite holds the bijection and the argument derivation with it. So the MCP surface cannot grow a capability this contract lacks, nor this contract an AI-callable action the surface hides. Nor can a tool's action take an argument the tool cannot carry, save a member marked `x-wire-only` that no setting opens to the tool, which the wire alone carries.

MAPI-09 (decided): The super-admin's actions are enumeration rows like any other, marked `grant: super_admin`, the grant that exists only in Turn Zero's own accounts (ACB-L0-71), per credential and never by default. A row carries one grant mark. `super_admin` admits every grant-marked row whichever grant marks it: the dispatcher's grant gate admits a credential holding the row's grant or `super_admin`. The gate also admits a credential whose bounding grant the row's `admits` mark names (MAPI-16). A credential holding a narrower grant alone reaches, among the grant-marked rows, those marked with that grant, those whose `admits` mark names it where it bounds the credential, and no other.

The operator set that carries `super_admin` is the control plane's setting `SUPER_ADMIN_IDENTITIES`, comma-separated entries of the form `<provider>:<subject>`. The provider is one of the builder realm's two federated providers, `google` and `github`, and the subject is the provider's stable subject as the realm's identity row stores it, never an address. A process refuses its boot by name on an entry with no provider or no subject, a provider outside the two, or a subject carrying `@`. A release meets that refusal at its readiness step, the prior revision still active (PLD-L0-65). Where every identity in the set has lost its sign-in routes, the operator authority is restored by a new entry in the setting's committed row, released under the operator's sign-in to the hosting subscription, which needs no operator credential.

The grant a session carries is read live and stored on no user or session row. Where a builder session, the dashboard cookie, or the browser action route resolves to a credential, the account's bound identities are read with the realm user's row. The credential carries `super_admin` where one of them is in the set, unless the session's binding carries the bound `device_sign_in`, which withholds the grant whatever the set names (MCP-02; MAPI-16). An entry removed from the setting therefore ends that grant at the next request. An operator token (MAPI-14) keeps the grants its minting fixed while its account holds an identity in the set, and resolves to no credential while it holds none (MAPI-14). So removing an entry from the setting refuses the person's operator tokens while their account holds no identity in the set.

This paragraph states one unmarked row whose subject the grant widens. `read_status` admits an application of any account under a credential holding `super_admin`, read-only, so the operator's move reads the row it started (PLD-L0-84). Across accounts it withholds what the tenant's logs, manifest, and application wrote, the console lines, answer bodies, and refusal details of each row among them, and refuses `tables: true`, reaching no tenant data (ADM-L0-10).

Among the grant-marked rows the grant admits those eight alone, and it bounds the token that carries it. A minted token holding `synthetic_estate` and not `super_admin` is admitted to those eight rows, to the rows the enumeration marks `admits: ["synthetic_estate"]`, and to the rows marked `access: anonymous` (MAPI-11), and is refused every other row of the account by name. A token minted with both grants is `super_admin`'s and is bounded by nothing. What the narrow grant reaches within each row, what within them stays `super_admin`'s alone, and the bound with its refusal, MAPI-16 states.

`feedback_queue`, the fifth grant, marks no row. It is given on MAPI-14's terms, bounds the token that carries it as MAPI-16 states, and widens two unmarked rows, `read_feedback` and `settle_feedback` (MAPI-18; API-L0-20), which carry it under `admits`, the grant decided at each handler. The settling of the platform's own queue is the company's act on the platform's own record of its friction, naming no customer account and reaching no customer's data. So a token holding the grant and not `super_admin` is admitted to those two rows and to the rows marked `access: anonymous` (MAPI-11). It is refused every other row by name, the grant gate answering first on a row another grant marks (MAPI-14).

Under the queue's grant the queue form, the whole read of any issue by its id, and the settling of an issue of the platform's own space answer, and the read with no member answers the operator account's own submissions (MAPI-18). With `application`, `settle_feedback` settles an issue of the acting account's own application space with no grant read (ITS-L0-03). `issues`, the sixth grant, is a space grant any session of the account gives for one space it holds (MAPI-14); it marks no row and bounds its token to the relay (MAPI-16).

The grant-marked rows are therefore thirty-three in all, a `super_admin` credential reaching all thirty-three, a `synthetic_estate` credential the eight, a `publication` credential the two, and a `feedback_queue` credential none, the grant marking no row. `synthetic_seed_purge`, the seventh grant, marks no row either: a credential it bounds reaches three of the estate's eight by their `admits` mark (MAPI-16). `tzmesh`, the eighth, is a product grant on `issues`'s pattern, given by any session of an account holding the `tzmesh` profile (MAPI-14); it marks no row and bounds its token to `list_tokens`, `submit_feedback`, and the anonymous rows on this plane (MAPI-16). `device_sign_in`, the tenth, is the bound of a session the device grant issued and no token's grant; it marks no row and reaches no grant-marked row (MCP-02; MAPI-16).

Deleting a customer's account is not a further marked row. It is the same `delete_account` action through the same pending action (API-L0-07), the grant widening the subject an operator credential may name and nothing else: same API, same tiers, same record, which is API-L0-12's whole claim.

Administering the builder realm is not a further marked row either. `invite_end_user` called with no `application` member, naming `email` or `invitation`, `list_invitations`, `application` optional, called with none, and `configure_app_sign_in` called with none address the builder realm (ACS-L0-08; ACS-L0-07). The three rows are unmarked, and that application-less form is admitted to a credential holding `super_admin` alone. It is refused by name to every other credential, and refused `token_scope_refused` to an application-bounded token, the form naming no application the token is bound to (API-L0-17). So the grant widens the subject an operator credential may name on an unmarked row, the builder realm in place of a realm of the caller's own application, exactly as it does on `delete_account`. The action record and the meter name the builder realm as the subject (MAPI-06).

The queue form of `read_feedback`, the read called with `queue` (MAPI-18), is the same pattern on a further unmarked row, the widening grant the queue's own. The form is admitted to a credential holding `feedback_queue` or `super_admin`. It is refused `grant_required` naming `feedback_queue` to every other credential that reaches the handler, and `token_scope_refused` to an application-bounded token, the scope gate answering ahead of the handler in MAPI-14's order. The read without `queue` answers every credential its own submissions. The read with `issue` answers a credential holding either grant any account's submission by its id and every other credential its own alone, another account's answered `not_found`. The `super_admin`-marked rows are twenty-three, the `synthetic_estate`-marked rows seven, the `publication`-marked rows two, and no row carries `feedback_queue`, thirty-two grant-marked in all. A test in the platform's suite holds each count: twenty-three, seven, two, none, and thirty-two.

This statement records a use of MAPI-02's shape clause on the action `add_product`, removed with its MCP tool, since no product is added to one account (ACB-L0-76). Over the actions route a call naming it answers 404 `unknown_action`, and the tool surface moves with MCP-08's revision 7. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, and `schemas/mcp_surface.json` move with it. The coordinating session approved the removal under family:Q-277, on Anthony's direction that no product is turned on or off per account. The platform then held 81 builder accounts, synthetic accounts excluded, read from the control database at the change.

`buy_credits` is an unmarked, reversible account row, addressed as `read_balance` is and admitting the bearer and browser-session clients (ACB-L0-101; ACB-L0-102). It reads only the calling account, writes a purchase and calls the payment provider. It opens checkout, takes no payment and needs no pending approval. Each call starts a new purchase and ends the earlier open checkout, so it is not idempotent. The row remains enumerated while credit sales are off; its handler then refuses `credit_sales_off`. It adds no grant-marked row to the inventory.

MAPI-10 (decided): The wire surface is uniform and derived: every action is an HTTP endpoint at the address its row's `surface` derives — POST for every tier, GET additionally for the observe tier — built from the enumeration at server start. A route therefore exists exactly when its action does, which is MAPI-01 enforced on the wire rather than reviewed onto it.

The addresses are these. An `account` row answers at `/api/v1/<action_name>` on the estate's origin, each registered from the enumeration and never as a prefix, since `/api/v1/` also holds the cookie address, the start-line route, the account mail route and the support routes. A `tzcloud` row answers at `/api/tzcloud/v1/<action_name>` and a plane-made `tztrack` row at `/api/tztrack/v1/<action_name>`, the origin paths the edge forwards `tzcloud.turnzero.ai/v1/<action_name>` and `tztrack.turnzero.ai/v1/<action_name>` to. Where an estate deliberately sets no host for an origin path, as the suites' local plane and any `TURNZERO_CLOUD_ORIGIN` do, the plane serves that path on its own origin (PLD-L0-67).

The HTTP action route, wherever a statement names it, is a row's address under a bearer credential. Each of the three takes the bearer guard alone and admits no cookie, except the page-only rows MAPI-03 states. A name of another surface, or a renamed one, answers `unknown_action` carrying `address`, the address that serves it or its successor. Any other name answers `unknown_action` with no `address`, and a segment another route serves under `/api/v1/` is never read as a name.

The cookie address is `/api/v1/actions/<action_name>`. It stays served to the signed-in site's cookie calls (MAPI-03; WEB-L0-16) and to a request presenting no bearer credential. A bearer call there answers 410 `action_address_moved`, carrying `address` and naming the action, from the Authorization header alone, so a presented value that resolves to nothing answers the same and the answer reads no credential. The admission gate and the JSON body parser run ahead of it, as they do for any action. Its detail names the update where the `User-Agent` starts with a command token (PLD-L0-109), as MAPI-02 states for a retired name, and otherwise names the address and that a tool making the call needs its update.

Every response carries the contract version (MAPI-02). Every refusal is the wire error shape at `schemas/wire_error.schema.json`. Its six base members are the version, a machine-readable error slug, the action where one is in question, a human detail, the reference the action dispatcher minted for the call (API-L0-19), and `help`, the address of the refusal's explanation. The reference is admitted and not required, as the action and the detail are, and it is carried by every refusal the action dispatcher answers to a dispatched call.

`help` is admitted and not required. It is carried by every refusal the action dispatcher answers to a dispatched call, and by the `unknown_action`, `method_not_allowed`, and `not_yet_provisioned` refusals the actions routes answer before dispatch. It holds the address of the refusal's row on the refusals page, `<origin>/cloud/reference/refusals/#<refusal name>`, on the estate's configured public origin (MCP-02). Where that origin is a loopback or an `http` one, the address is composed on the production origin instead, so a local run names the page production serves.

Beyond the base members, on the management action surface, a refusal carries exactly the members its row of `schemas/wire_errors.json` names under `members` (MAPI-15). Each is admitted and none is required, so a body that omits one stays valid. A member no row names for that refusal is a defect of the body or of the row. This is MAN-12's named-refusal discipline applied to the plane itself: a caller reads a violated path, a plan's floor, or a conflicting schedule as a typed member and never parses it out of the detail.

A grant is one such member, `grant`, named and described by the row of each refusal that answers it. Under `grant_required` it is the grant the action requires in the form called: a grant-marked row's own, or the grant the statement owning that form names for it. Under the other refusals it is the grant requested or held.

The schema file's member region, its declarations beyond the base six and its conditionals, is generated from the rows and never written apart from them. The file stays closed, declares every member any row names, and admits each under the refusals whose rows name it and under no other. The platform's suite holds the file equal to its generation from the rows, and holds every refusal the action dispatcher answers under test to the file.

This paragraph qualifies the member and suite-check rules above for the refusals on the suite's closed list in MAPI-15. While that list holds a name, a listed body is checked against the six base members alone. Extra members on a listed body are not violations, but a base member in the wrong form still is. The five listed bodies with members of their own are held by the cases that answer them. The schema stays generated from the catalogue rows that remain, and every other refusal keeps the whole rule. The exception ends when the list is empty.

Three rules hold on every surface a customer or a public caller reads, among them the router's and the egress gateway's own refusals, the version row's outcome read through `list_versions`, and a deletion walk's receipts read through `read_approval_status`. A refusal a thrown transport failure produced — Node's `fetch failed`, whose deciding fact rides the error's cause — carries in its detail the message with the cause's code alone beside it, `fetch failed (ENOTFOUND)`. It never carries the cause's message, which can name an address inside the platform's network. A raw socket error is what `http.request` and `https.request` reject with, the router's application leg among them: its code is on the error itself with no cause, and its own message names the address the leg dialled. It carries a fixed sentence with that code alone beside it, `the connection failed (ECONNREFUSED)`, and never its message.

A refusal the provider answered is a status the management plane, a storage account, or the registry returned. Its own message names the platform's subscription, a resource group, a request identifier, the registry's login server, or the provider's vocabulary. On those surfaces it carries a fixed sentence with the status word alone beside it, `refused by the provider (http_403)`, or `failed (error)` where no status rode and no code of the transport's classifies, and never the provider's message. An operator diagnostic — a control-plane record, a run stamp, a command's standard error, the operator's own dashboard — carries the cause's code and message whole, a socket error's message whole, and the provider's message whole. So a lookup a network blocked, a certificate a firewall replaced, and a right the platform's identity lacks each read as what they are and never as an outage.

A thrown error whose transport code stands only along its cause, and whose own message is neither Node's `fetch failed` nor a raw socket error's, is the platform's own wrapper, its message composing an operator's text. On those surfaces it carries the fixed sentence with that code alone, `the connection failed (ECONNRESET)`, and never its message.

A container provision the provider failed because pulling the application's image answered 429 or a 5xx status is a refusal the provider answered, its message naming the registry's storage host and the provider's vocabulary. On those surfaces it carries a fixed sentence naming the busy image registry with that status word alone beside it, `The image registry was busy (http_503)`, and never the provider's message. The sentence says the fault is the platform's and transient, and names the act to call again.

An unknown action refuses as `unknown_action`, never a bare 404 page. A mutating action reached with GET refuses as `method_not_allowed`. An action whose implementation has not arrived refuses as `not_yet_provisioned`. The approval row's restriction (MAPI-05) and a page-only row's admission (MAPI-03) are enforced at authentication, never by hiding the route.

This statement records the seventy-eighth use of that clause. The row `declared_audience_contradicts_route` lost its member `routes` and gained `sign_in_methods`, admitted and not required, the same array of the realm's configured sign-in methods under the realm member's new name (ACS-L0-07; MAPI-02). The refusal keeps its name (MAPI-15), the schema file's member region was generated again from the rows, and no other row's member changed. The platform then held one builder account and no standing synthetic account, read at the change.

This statement records a use of MAPI-02's shape clause on `schemas/wire_errors.json`: the row `unknown_action` gains the member `address`, admitted and not required, the address that serves the named action or its successor, and the row `action_address_moved` is added. `schemas/wire_error.schema.json`'s member region is generated again from the rows, and no other row's member changes. The platform then held 6 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

ACB-L0-22 records the use of MAPI-02's shape clause on `set_plan` and the plan members, and names the refusal rows that left the catalogue with them.

MAPI-22: **A call that names a member its action does not declare is refused by name, on every surface: the HTTP route, the tool surface, and the console.** The refusal is `invalid_request`. So a caller that misnames a member is told which member it sent, and is never answered as if it had sent none.

What an action declares is the `properties` of its request in `schemas/action_payloads.json`. A request's root is closed. A nested object whose schema carries `properties`, empty or not, is closed too. A nested object that carries none is a map and admits any member, and an array's items follow the same rule. On the HTTP route a member of the query string counts as a member of the body. A caller's `_origin` is refused, that member being the plane's own.

The detail names what the caller sent and what the action takes. It names each undeclared member, a nested one by its path, and then every member declared at that place, or their count as the paragraph on the budget states. It quotes at most five undeclared names and counts the rest. It quotes a name only where the name has a member's form, letters, digits, and underscores up to 64 characters. It never carries a value.

A member the contract replaced is answered with its successor. A request may carry `x-renamed`, a map from a member the request once declared to the declared member that took its place, and the detail then adds a sentence naming that member. A caller's guess gets no row. The four feedback requests carry the map for `application` and `environment`, which `space` replaced (MAPI-18). Their detail says which space a call naming none addresses, where the paragraph on the budget leaves `space`'s description whole.

A member the contract removed, with no member in its place, is answered with the reason. A request may carry `x-retired`, a map from a member the request once declared to a sentence that says why it is gone, and the detail then adds that sentence. A nested member's row is keyed by its path, as the detail writes it, such as `routes[].body`. On the tool surface a backticked action name in the sentence is named as the connection lists it (MCP-08). `submit_feedback`'s request carries the map for `personal` and `excerpt`: its sentence says that a report has no personal option, and that the caller files again without the member and leaves out what it does not want kept (MAPI-18). `request_route`'s carries it for `body`, at the top level and in `routes`: its sentence names `write_route` (MAPI-28).

A member declared beneath the root is named where it stands. Where a quoted name at the root is one the request neither replaced nor retired, and a member of the root declares it among its items' members or its own, the detail adds a sentence naming each such member. The call is still refused, since the name stands at the wrong place. On the tool surface a member marked `x-wire-only` is named in no such sentence.

The detail holds MCP-12's budget for a refusal's detail. Where the names of the declared members would pass it, the detail gives each place's member count instead, with the address of the action's reference page, which lists them. Where the address would pass the budget too, the detail gives the page's route without its origin. Where the detail still passes the budget, a successor's description stops at its first sentence, and then the detail gives the successor's name alone. Then it says only that the action's reference page lists them. Last, the sentences naming where a quoted name is declared leave, the last first, since no rule rests on them. The quoted names, the count of the rest, and each retired member's sentence always stay.

The check stands in the dispatcher, behind its access gates. It runs after the refusal of text the plane cannot hold (PLD-L0-91) and after every access gate: the scope, grant, and bound gates, and the destructive class's (MAPI-12). So an access refusal keeps its name, and a credential the row does not admit is told no member names. It runs before a pending act is described, so a refused call creates none. Each surface hands the dispatcher the caller's member names and no value. A body that is not a JSON object is refused at the same place, in words that name no member. The replay of a stored input is not checked again.

On the tool surface the refusal answers before the argument layer validates the call. A single tool call that carries an undeclared member is handed to the dispatcher as the HTTP route hands a body. So a call that misnames a required member is answered with the member it sent, not with the member it lacks.

A single tool call with an object missing a declared required member is also handed to the dispatcher and refused naming each missing member; missing top-level members, null values and objects reached through arrays keep the argument layer's answer.

A batch of calls keeps the argument layer's order, and a request the transport refuses for its headers keeps that refusal. The members the detail lists on this surface are the tool's arguments, a member marked `x-wire-only` left out (MAPI-08). One exception stands: a tool call whose only member outside the tool's arguments is marked `x-wire-only` keeps the answer MAPI-08 gives it. A call that also names an undeclared member is refused by name.

The served-surface suite holds the rule for every action, on each surface that serves it.

MAPI-11: Action rows carry the access marking where MAPI-09 carries the grant marking. An action row marked anonymous stands outside every grant's bound (MAPI-16) and needs no acting identity: the library’s inventory and content reads (LC-02), and the platform context catalog and content reads (CTX-07). On the wire every marked row, `read_library` and `read_context`, answers a request presenting no credential, or one resolving to no account, the challenge MCP-02 states (API-L0-15). The one exception API-L0-15 names is an unmarked row: `search_documentation` answers a request presenting no bearer credential the signed-out search CTX-10 states. Over MCP any connected identity reads it, since MCP-02 challenges a connection presenting none. An unmarked action answers as the connected identity behind the standard challenge (the 401 pointing at the protected-resource metadata, CQ-189's machinery).

The anonymous platform_context observe actions additionally retain a supplied valid, active bearer or minted credential, checking the required OAuth scope where that credential is OAuth-bound, for their credential-filtered view and attribution. On the wire and over MCP alike, a credential that resolves to an account without acting, suspended or unscoped, reads the anonymous view, and an absent or unresolved one draws the challenge (MCP-02). Over MCP such a credential's message requiring an identity is refused 403. A resolved platform credential, end-user credential or transfer grant retains its named kind refusal. The library HTTP routes take the same identity rule, a non-acting account reading the library as any does.

The marking is the enumeration’s own member: the server derives its authentication gate from it, the wire's marked rows challenging as the first paragraph states. No surface keeps a hand-curated set beside it, and the suite holds every action to a marking-consistent gate (Q-239).

MAPI-12: The destructive class is granted by presence. A session credential minted by a person's own browser sign-in carries the destructive class from its minting — the sign-in is the explicit grant API-L0-06 requires. A minted token (API-L0-05) takes the class only at its own minting, from a session holding it (MAPI-14), and from nothing afterward. The application's platform credential (SEC-L0-07), the end-user credential the accounts service issues, the transfer grant object storage mints, the secret grant (SEC-L0-19), and the egress key (SEC-L0-18) hold no destructive class and can be granted none. A credential kind added later holds none until its own statement says otherwise (API-L0-06). The check runs where a destructive request arrives, before any pending action is created, and its refusal names the missing grant — a refusal distinct from the pending path, so an ungranted caller cannot fill a person's browser with approval requests.

A token code (MAPI-23) holds no destructive class and can be granted none; the token its exchange mints takes the class only as a minted token does, at the code's mint, from a session holding it.

MAPI-14: A minted token is created by `mint_token` (reversible tier), callable by the session credential alone — never by another token, the platform credential, or an anonymous caller — but for the fifteenth paragraph's exchange form. A support read token is minted by the support consent route alone, and never by `mint_token` (MAPI-29). Or, for a synthetic account alone, it is minted by the staff seed of synthetic accounts through the same code path under a credential the seed's row admits: a session holding `super_admin`, or a minted token carrying `synthetic_seed_purge`, `synthetic_estate`, or `super_admin` (MAPI-09). So a harness holding a token carrying either synthetic grant mints the fixtures' tokens and no other (MAPI-16).

`mint_token` names its scope (the account, or one application of it), an optional expiry, an optional label, the grants requested, and `code_challenge`, which is required. Under the challenge the call mints a token code in place of the token and answers no value, and the optional boolean `authorized_computer` marks an authorized computer's token, each as the fifteenth and seventeenth paragraphs and MAPI-23 state. A call naming no `code_challenge`, or one of another form, is refused on each surface as MAPI-23 states, nothing minted. The destructive class (MAPI-12's explicit grant) and `super_admin` (MAPI-09) are each given only where the minting session holds it and refused by name otherwise.

The seven narrow grants are `synthetic_seed_purge`, `synthetic_estate`, `publication`, `feedback_queue`, `issues`, `tzmesh`, and `tztrack`. `synthetic_seed_purge` is the one the seed, the purge, and the purge's read admit (MAPI-16), and `synthetic_estate` the one MAPI-09 marks the synthetic estate's rows with. `publication` is the one it marks the two publish rows with, `feedback_queue` the one `read_feedback` and `settle_feedback` admit (MAPI-18), `issues` the space grant the next two paragraphs state, and `tzmesh` and `tztrack` the product grants two later paragraphs state. Each bounds the token that carries it to the reach MAPI-16 states. The first four are given only where the minting session holds `super_admin` and refused by name otherwise. At most one of the seven is given to a token that takes no `super_admin`, a request naming two refused 400 `invalid_request` with nothing minted. None of `super_admin` and the seven narrow grants is given to an application-bounded token (API-L0-17).

`issues` is given by any session of the account for one space the account holds, where the account holds the `tztrack` profile, the gate on the issue spaces (ACB-L0-89). The request names the space in `space`, a lower-case UUID `list_issue_spaces` answers, the level in `level`, `report`, `contribute`, or `owner`, and a `label`, each required with the grant and refused `invalid_request` where absent; `space` or `level` without the grant is refused the same. The label names the holder in printable characters, and no unrevoked token of the account carries it for the same space, expired or not, until the daily pass deletes the row (PLD-L0-67). A duplicate or a non-printable label refuses `invalid_request`, and the level is not capped by the space's kind. The relay names the acting actor as the account's identifier qualified by the label (the issue service PRD's relay row).

For a space shared with the account, `mint_token` refuses an `issues` grant above the account's membership level as `issues_level_refused`, naming that membership level. At `view`, it refuses every `issues` grant for that space as `issues_level_refused` (ITS-L0-07).

Without the grant, a `space` naming a space the account does not hold is refused `space_not_owned` ahead of the form, the identifier judged before the form as every identifier is (VER-11).

A space the account neither holds nor is a member of is refused 403 `space_not_owned` naming the space, whatever the session holds. That is another account's unshared space, an unknown one, the platform's own space to every account but the one the plane names its owner, and an application's space until a binding records it (the issue service PRD's relay row). `space_not_owned` is this statement's row of `schemas/wire_errors.json` (MAPI-15), answering the mint, the relay, and `create_space` under one name.

The gate is read once the owner is judged. An account that lacks the `tztrack` profile is refused 403 `blueprint_required` with nothing minted, whatever the space's kind. On a shared space the owner's profile is read beside the member's, and a mint is refused the same where the owner lacks it (ACB-L0-89). The relay reads the same profile on each call, and `create_space` reads it before it creates anything (the issue service PRD's relay and provisioning rows). `blueprint_required` is ACB-L0-89's row of `schemas/wire_errors.json` (MAPI-15).

`tzmesh` is given by any session of an account holding the `tzmesh` profile (ACB-L0-76), with a `label` naming the holder in printable characters, required and refused `invalid_request` where absent; `space` rides `issues` alone. The grant takes no `level`: a call naming one with it is refused `invalid_request` with nothing minted, and the grant mints at the level `admin`, a mark that bounds no `tzmesh` call (MAPI-03). A label may repeat across the account's `tzmesh` tokens, and `mint_token` refuses a non-printable one `invalid_request`. An account lacking the profile is refused 403 `tzmesh_required` with nothing minted. The code's exchange reads the profile again and answers by that name, as MAPI-23 states. `list_tokens` and the mint's answer carry the level as `level`. The token's expiry and its signed form are the paragraph after the operator token's.

The exchange's answer carries the value exactly once beside the token's identity, and no `mint_token` call under a session credential answers a value on any surface (API-L0-05). The mint call's `token` member carries the properties the exchange mints with and no identity (MAPI-23). The store holds the value's hash, the scope, the grants, the label, the revocation, and the authorized computer's marker, never the value. It holds the three stamps — the minting, the expiry, and the last use, which the credential seam writes as it resolves a presented value — and a space grant's space and level.

`revoke_token` (reversible) ends one token by its identity, and `list_tokens` (observe) answers identities, scopes, grants, labels, a space grant's space and level, and all three stamps, the last use among them, never values, and the exchange answers that shape for the token it mints. `list_tokens` also answers `authorized_computer`, true on an authorized computer's token and false on every other. On a `tzmesh` or `tztrack` token, it and the exchange also answer `last_used_note`, one sentence saying the last use counts only the requests this plane answers. The product's own service checks such a token with no call to the plane (MCP-02), so a null stamp there does not mean unused. `revoke_token` is idempotent: a repeat answers the row with its first revocation stamp. Once the daily pass has deleted the row, after the retention PLD-L0-67 states, `list_tokens` lists it no more and `revoke_token` naming it answers `not_found`.

The exchange and `revoke_token` each write one line into the control plane's own diagnostics (system:LGS-L0-16) carrying the token's identity, its scope, its grants, its label, and its expiry, and never the value. The mint call writes the line the nineteenth paragraph states, naming the code's identifier. The fixtures the staff seed mints through the same code path write none, as do the sweeps an application's deletion and an account's erasure run, and the ends MCP-02 states of the tokens an authorization exchange issued, each being another act's. The operational record answers no reader (MAPI-06), so that line is where an operator reads what was minted under an account and when it ended. The `tzmesh` exchange's mint writes the same line, naming the client and the tokens its act revoked.

A revoked or expired token is refused at once on the management surface and the MCP endpoint, and on the storage, egress, and logging wires at the gateways' next read past their cache interval (PLD-L0-67). A stored token whose grants name one outside the grants the running build serves resolves to no credential, refused `authentication_required` as an absent credential is. So a build that predates a narrow grant never serves that grant's token unbounded. A minted token renews nothing — it is replaced by minting another — and its grants admit nothing its minting session's grants did not admit (MAPI-09). Every action a token performs is recorded under the token's own identity (MAPI-06): a credential identity on the record beside the kind, empty where the credential has none.

Its refusals run in one order, each named and none creating a pending action. The scope comes first (API-L0-17). Then, on a row whose implementation has not arrived, comes `not_yet_provisioned` (MAPI-10). Then comes the grant (MAPI-09), under which a grant-marked row that does not admit the token keeps `grant_required` with the row's own grant. Then comes the bound of a token a narrow grant bounds, `synthetic_seed_purge_bounded`, `synthetic_estate_bounded`, `publication_bounded`, `feedback_queue_bounded`, `issues_bounded`, `tzmesh_bounded`, or `tztrack_bounded` by the grant (MAPI-16). A session the device grant issued meets its bound at the same place, refused `device_sign_in_bounded` (MAPI-16). The destructive class comes last (MAPI-12).

This paragraph names the exchange, the first paragraph's one exception: `mint_token` on the HTTP action route under a token code the session's own call minted, which mints the token from the code's row and answers its value once, as MAPI-23 states. Its held form presents the verifier whose challenge the code recorded and names the mint by its id, as MAPI-23 states too.

The code's mint runs every refusal of this statement's mint before it mints, and the exchange reads again what the mint read, each as MAPI-23 states.

`authorized_computer`, an optional boolean, marks the token of an authorized computer, the one the turnzero command keeps on the computer whose challenge the call names (PLD-L0-104). The marked mint is made in two places through one function. One is this call under a tool's session, which a signed-in tool makes itself and then reports to the person. The other is the computer login page under the browser session credential the approval cookie builds, where the person approves their own `login` (WEB-L0-25; MAPI-23). A marked token is account-scoped and lives at most 30 days, 30 where `expires_in_days` is absent. A marked mint naming `scope_kind` `application` or `expires_in_days` above 30 is refused 400 `invalid_request` with nothing minted, the cap a refusal and never a clamp. The exchange writes the marker on the token's row, and `revoke_token` ends the token as it ends any.

This paragraph states `completion`, an optional tool argument of a marked mint, carried over MCP and the wire alike, whose one value is `mint` (MAPI-02; MAPI-22). An unmarked mint whose grants are `["tzmesh"]` alone takes it too, and asks by it for the held answer. A marked mint made by a tool's session, over MCP or the HTTP action route, is answered the held line, which names the mint by its id and holds no code, whether or not it names the argument. The computer login page's mint keeps its code outside its device mode (WEB-L0-25), as MAPI-23 states. The turnzero command's first act prints it among the call's members where it takes that line, and a tool names it only where that first act printed it. Another value, or the argument on an unmarked mint this paragraph does not admit, is refused 400 `invalid_request` with nothing minted.

The mint writes one line into the control plane's own diagnostics naming the code's identifier, the session's kind, the scope, the grants, the label, the marker, and the code's expiry, and no value. The exchange writes the twelfth paragraph's line for the token it mints, naming the code's identifier beside the token's (MAPI-23).

This paragraph and the next add the `tzmesh` exchange as the first paragraph's second exception (MCP-02). The token endpoint's exchange, for a registered client that named the `tzmesh` resource, mints one signed `tzmesh` token at the level `admin` under the client's name, as MCP-02 states. It mints on the profile the paragraph on `tzmesh` states, read through the one rule (ACB-L0-76) at a tool's completion and again at the exchange. An account lacking the profile is returned `access_denied` at the completion and refused `invalid_grant` at the exchange, no product word in either answer.

The mint records the client the token was issued to and revokes, in the same act, each unrevoked `tzmesh` token of the account and label that client was issued, so a tool's earlier token is replaced and no other is. Another token of the label, one `mint_token` minted or another client was issued, stands beside it, so a tool on a second computer leaves the first computer's token standing. The token's value is the signed form MAPI-03 states, answered once at the exchange, and it expires 180 days after its mint (API-L0-05). The exchange's end of a token it minted while the generation moved writes `revoke_token`'s line.

This paragraph qualifies the two above for the `tzmesh` site's own sign-in client (MCP-02), whose sign-in holds no page. Its code exchanges for a `tzmesh` token at the level `chat` under the label `Sign-in at <host>`, the callback's host, with a life of one minute from its mint. Its whole use is the service's exchange and its one `register_human` call. Where a same-origin post of the site started the sign-in with an intent, its use also covers the one `register`, `attach`, `remove_listeners`, `delete_agent`, or public `create_channel` the callback makes in the service's own process. The value is then dropped, never kept. The replacement rule stands, so one unrevoked row of the label stands for the client per account.

This paragraph qualifies the two paragraphs that add the `tzmesh` exchange for a builder's application, a request naming the scope `tzmesh.application` (MCP-02), whose sign-in holds one line at its first sign-in to the client and no consent screen. Its code exchanges for a `tzmesh` token at the level `chat`, issued to the client, under the label `<name> at <host>`, whose name, fallback name, and cut MCP-02 states. The token's life, the replacement rule, and the label rules stand as written. The token's payload carries `application_sign_in` (MAPI-03), which the `tzmesh` service reads as system:XTX-02 states.

This paragraph adds the device-code exchange as the first paragraph's third exception (MCP-02; RFC 8628). The token endpoint, under the grant `urn:ietf:params:oauth:grant-type:device_code`, answers a device code the person allowed on the verification page the resource's exchange answer. For the `tzmesh` resource that is one signed `tzmesh` token at the level `admin` under the client's registered name, the two paragraphs that add the `tzmesh` exchange applying whole, the profile read again at the exchange. For the `tztrack` resource it is the `tztrack` token the paragraph adding that exchange states. For the plane's own resource it is the session the paragraph after the next states, which mints no token and is no exception of the first paragraph.

The endpoint answers each device code once, deleting its row as it answers, so a second poll is refused `invalid_grant`. Before the approval it answers `authorization_pending`, and a poll inside the interval `slow_down`. A code past its ten minutes, allowed or not, is answered `expired_token`, and a cancelled request `access_denied`, each 400 by name. A `client_id` no registration names is refused `invalid_client` ahead of the grant, and a device code of another client `invalid_grant`.

This paragraph states the device grant's answer for the plane's own resource or a customer MCP address's (MCP-02). The endpoint answers an allowed device code with the builder realm's session and its refresh token, as the authorization code's exchange answers one (MCP-10), at the generation the verification page's sign-in captured (ACS-L0-11). The session's binding carries the bounding grant `device_sign_in`, read as a bound at every seam MAPI-16 names, and the session holds no `super_admin` whatever its account holds (MAPI-09). The grant is no grant of `mint_token`'s list: a mint naming it is refused `invalid_request` as any grant outside the list is, as `support_read` is (MAPI-29). A stored token row naming it resolves to no credential. A device session calling `mint_token` is refused `device_sign_in_bounded` by the bound, so it mints nothing (MAPI-16).

This paragraph adds the `tztrack` exchange as the first paragraph's fourth exception (MCP-02), served where the plane names the tzTrack origin. The token endpoint's exchange, for a registered client that named the tzTrack resource, mints one signed `tztrack` token at the level `admin` under the client's registered name, or `MCP client` where it registered none. It reads the `tztrack` profile through the one rule at the exchange alone (ACB-L0-76; ACB-L0-89), no consent page standing: an account outside the gate is refused `invalid_grant`, no product word in the answer, and nothing minted.

The mint records the client the token was issued to and revokes, in the same act, each unrevoked `tztrack` token of the account and label that client was issued; another token of the label stands beside it. The token's value is the signed form MAPI-03 states, answered once, and it expires 180 days after its mint (API-L0-05); its reach is MAPI-16's. The token takes the destructive class at that minting, since the sign-in that holds the code is a person present, as a minted token takes the class at its own minting from a session holding it (MAPI-12; API-L0-06). MAPI-16's bound keeps the token to the rows admitting the grant, among which `delete_space` alone is destructive, and only the browser approves its pending action (API-L0-07). `list_tokens` lists the class among the token's grants.

A request naming an application id that a live application of another account carries is refused 403 `application_other_account`, in `no_such_application`'s place, under every credential. Every management action that resolves an application by its id answers it so, through the dispatcher's one path, and so does the storage surface's area declaration. The refusal is recorded and metered under its own name (MAPI-06). An id no live application carries is refused `no_such_application`, as each surface states.

The refusal's detail opens by saying the application belongs to a different account than the one the request is signed in as. It then names the acting account. Under a marked token that is the account's sign-in address, the address `read_account` answers a session as `address`. Under every other credential, and where the address would carry the detail past its budget (MCP-12), it is the account's id. The detail closes with the likely cause: the turnzero command and the AI tool's connection are signed in to different accounts, so compare `whoami` with `read_account` over the connection. The `whoami` line carries `--origin` where the origin is not the command's default (PLD-L0-104). Where no name fits the budget, the acting-account sentence is left out.

The detail names nothing of the account that holds the application: not its id, its address, or its name, nor the application's name. It never says to log out, which would sign the command out of an account the person also uses. The lookup that tells the two refusals apart is the store's read by id, unscoped by account, made on the refusal's path alone. The refusal tells a caller that some account holds the id and nothing more. An application id is a random UUID, and the edge's admission window bounds each source's requests (PLD-L0-67).

A refusal `no_such_application` answered under a marked token names the account the call acted as. A management action and the storage surface's area declaration answer it so. The detail keeps the surface's own sentence first and adds one, naming the acting account by its sign-in address, or by the account's id where it has none or the address would carry the detail past its budget (MCP-12). Under every other credential, and where neither fits the budget, the detail is the surface's sentence alone.

An operator token is a minted token whose grants hold `super_admin` or a grant the mint gives only under it: `synthetic_seed_purge`, `synthetic_estate`, `publication`, or `feedback_queue`. An operator token whose account holds no identity in the operator set (MAPI-09) resolves to no credential. It is refused `authentication_required` as a revoked token is. Every process that can admit an operator token carries the operator-set setting, and the internal service, which admits none, carries none.

This paragraph states a product token's expiry and its form, one rule for each product grant. The token lives at most 180 days, 180 where `expires_in_days` is absent; a mint naming more is refused 400 `invalid_request` with nothing minted, the cap a refusal and never a clamp, on the authorized computer's pattern. The mint also reads the plane's origin for the product, and a mint on an estate naming none is refused 400 `invalid_request` with nothing minted. The code's exchange mints the signed form MAPI-03 states, signed by the accounts service under a single-use ticket as MAPI-23 states, and answers its value once. `revoke_token` ends the token, whose row then stands on the product's revocation list (MCP-02); `list_tokens` lists it with its level.

`tztrack` is given by any session of an account holding the `tztrack` profile, the gate on the issue spaces (ACB-L0-89), with a `label` naming the holder in printable characters, required and refused `invalid_request` where absent; `space` rides `issues` alone. The grant takes no `level`: a call naming one with it is refused `invalid_request` with nothing minted, and the grant mints at the level `admin`, a claim the product's service reads and bounds no call by, its permission levels coming from membership. A label may repeat across the account's `tztrack` tokens, and `mint_token` refuses a non-printable one `invalid_request`. An account lacking the profile is refused 403 `blueprint_required` with nothing minted, the refusal naming no product; the code's exchange reads the profile again and answers it by its name, as MAPI-23 states. The token's expiry and form are the paragraph before this one's, and its reach MAPI-16's.

This paragraph adds `test_end_users`, a grant that bounds nothing. A token carrying it keeps its scope's reach, and the grant admits it to the test end user acts on the realms where ACS-L0-21 refuses another minted token. Any session of the account gives it, on an account token or a token bounded to one application, beside the destructive class, and beside `super_admin` on an account token. It is refused 400 `invalid_request` with nothing minted beside any of the seven narrow grants, each bounding its token to rows that hold no realm act, and on a marked mint, whose members the command's first act prints. `list_tokens` lists it in `grants`, beside the label, the scope, and the stamps.

The `test_end_users` grant takes a `label`, required and refused `invalid_request` where absent, naming the holder in printable characters. No unrevoked token of the account carrying the grant holds the same label for the same scope, the account or the one application, expired or not, until the daily pass deletes the row (PLD-L0-67). A taken or non-printable label is refused `invalid_request` with nothing minted, at the mint, at the code's mint, and at the exchange (MAPI-23). The token lives at most 180 days, 180 where `expires_in_days` is absent; a mint naming more is refused 400 `invalid_request` with nothing minted, the cap a refusal and never a clamp.

This paragraph adds the support read grant to the thirteenth paragraph. A token carrying `support_read` resolves to no credential on the management surface, the MCP endpoint, and the storage, egress, and logging wires, refused `authentication_required` as an absent credential is. The support read routes alone admit it, the summary and the wider reads, each wider read running its named actions at the dispatcher's seam under the token: observe actions, and `relay_issue_act`'s `list`, `search`, and `read` alone (MAPI-29).

The closing is written at every call because a listener a `tzmesh` token registered outlives the token, which a suspension or the exchange's replacement may already have revoked, or which may have expired (MCP-02).

MAPI-23: The token code is a one-time grant every `mint_token` call under a session credential mints in place of a token, under the `code_challenge` the call names, admitted once at `mint_token`'s wire exchange form, where the exchange mints the token from the code's row. So no `mint_token` call under a session credential answers a token's value on any surface: the exchange answers it once, to the command that holds the verifier (API-L0-05; PLD-L0-104). That command is the turnzero command, or tzTeam's `connect` where its first act made the challenge (kit:GEN-09). The seed's once stands as MAPI-16 states.

The served descriptions carry the form's five members, `code_challenge`, `code_verifier`, `authorized_computer`, `completion`, and `mint`, and `mint_token`'s tool argument list carries `code_challenge`, `authorized_computer`, and `completion`, `code_verifier` and `mint` being the wire's alone (MAPI-08). `mint` takes a row's id or `device`, the device poll's value. The served value `token_code_seconds` (PLD-L0-76) gives every code but a device row its life, a device row living an hour, and the daily pass's step `token_codes_purged` (PLD-L0-67) removes the rows.

Under a session credential a call names `code_challenge`, 43 base64url characters, the S256 challenge of a verifier the caller's turnzero command, or tzTeam's `connect`, holds, runs every refusal of the mint, and then mints one code in place of the token (MAPI-14). The `issues` label rule is read from the account's token rows before anything is written, so a taken label is refused in the mint's words, no code minted. On the wire a call naming no challenge, or one of another form, is refused 400 `invalid_request`, nothing minted, its detail naming the command's acts that print one (PLD-L0-104). Over the MCP surface the tool's shape names `code_challenge` required (MAPI-08), so the transport's own validation refuses a call naming none before the handler, in the protocol's error shape naming the member, and a call naming one of another form meets the wire's refusal.

The call answers 200 with the state `awaiting_command`, `command`, `command_windows`, `command_npx`, `command_npx_windows`, `expires_at`, the code's, `token`, and `detail`, and no value. The computer login page makes the same mint under the browser session credential, through the one function this call's session mint runs, and shows its person no line (WEB-L0-25; MAPI-03). Outside its device mode, its approval sends the browser to the command's loopback port with the code, or shows the code once where the address carries no port, the page still stands a few seconds on, or the browser runs no script. `token` carries every property the exchange mints with, `scope_kind`, `application`, `grants`, `label`, `expires_at`, `authorized_computer`, and an `issues` token's `space` and `level`, and no `id` or stamps. The token's expiry is fixed at the mint, from the days the call named, or 180 days for a product grant's code, or a `test_end_users` code, naming none (MAPI-14).

This paragraph states a marked call's held answer. A marked call over MCP or the HTTP action route answers it whether or not it names `completion` (MAPI-14), and the computer login page's mint, outside its device mode, keeps the code-carrying answer whose code the page reads (WEB-L0-25). The call then answers `command` as `turnzero authorize --mint <id>` whatever its grants, the row's id, which is no credential, in the four line forms, and no code; the value the mint made is answered to no one. The `detail` says the line names the mint by its id and holds no credential, that the token is minted only when the command on the computer that printed the challenge presents its verifier, and to run it once, as given, there.

This paragraph states an unmarked call's held answer, which a mint whose grants are `["tzmesh"]` alone asks for by naming `completion` as `mint` (MAPI-14). The call answers `command` as `turnzero tzmesh register --mint <id>`, the row's id, in the four line forms, with no `--origin` on any estate, and no code; the value the mint made is answered to no one. The `detail` says the line names the mint by its id and holds no credential, and that the token is minted only when the command on the computer that printed the challenge presents its verifier. It says to run the line once on that computer, with the options that command's first act printed after it. The held form redeems the row as it redeems a marked one.

This paragraph states the device row, which the computer login page's device mode writes at its Approve for `turnzero login --device` (WEB-L0-25; PLD-L0-104). The page's mint names `completion` as `mint` and sets a field of the dispatcher's context that only the page sets and no route carries, so no member a tool names reaches it. The handler reads that field on the page's own mint alone, and marks the row `device`, a mark no other mint sets, which the mint's control-plane line names. The row lives an hour from the Approve, never past the approving session's row, and its mint answers the held line, of which the page shows nothing, reading only that it carries no code. A second Approve of a challenge whose newest device row stands unended and unexpired, by any account, is refused 400 `invalid_request` ahead of the label replacement, nothing minted and nothing ended.

`command` is one line that pipes the code to the turnzero command on its standard input, in none of its arguments: the general mint's, `token claim`. Outside device mode, the computer login page's own mint answers such a line naming `authorize`, which no command runs: the page reads the code from it and shows the line to no one (WEB-L0-25). It runs the installed command bare, `turnzero` (PLD-L0-94), and adds `--origin <origin>` where the estate's configured origin, never a host a request names, is not the command's default. `command_windows` carries the line's Windows form, and `command_npx` and `command_npx_windows` its npx form (PLD-L0-94). The `token claim` line's `detail` says it is a credential until `expires_at`, to run once, as given, and paste into nothing but the terminal that runs it. It says the person runs it, in a terminal outside the AI coding tool, and never a tool.

The `detail` also names the one exception: tzTeam's `connect`, whose first act made the challenge, runs its own completing line with the code (PLD-L0-104).

A token code is a grant of a kind of its own, the third beside the transfer grant and the secret grant, and its value has a grant's form (MAPI-03). Its record kind, on the action record, the authorization matrix, and the credential-surface census, is `token_code`. The plane stores it by its SHA-256 alone, in the control database's `token_codes` table (PLD-L0-67). Its row records the account, the minting session's kind and row key, which no record, answer, or log line carries, the challenge, every property the mint named, the marker, and the device mark. It also records the token's expiry, the code's creation and expiry, the instant and manner of its end, and the token it minted. A partial index over the device rows serves the reads by challenge.

A code lasts the served `token_code_seconds`, 300 seconds by default and held between 30 and 300 (PLD-L0-76), and a device row an hour, each never past the minting session's row's expiry. A later mint by the same session under the same label ends that session's unspent codes of the label, passing over its device rows.

The exchange is `mint_token` on the HTTP action route with the code as its bearer and the body `code_verifier` and no other member. There the dispatcher's kind gate looks the code up and spends it by one compare-and-set bounded by its expiry, ahead of every refusal of its own and ahead of the verifier's match. So every presentation there of a code the plane holds unspent spends it, whatever the call then answers, and two presentations of one code are admitted once.

The held form is `mint_token` on the HTTP action route with the verifier as its bearer, of the verifier's form and no credential prefix, and the body `mint` alone, the row's id. The form follows the bearer and the body: a grant-form bearer takes the code form, and a verifier-form bearer naming `mint` the held form. There the kind gate reads the row by its id. A body naming more than `mint`, a row absent, ended, or expired, or a challenge that is not the bearer's S256 hash is the one refusal with nothing spent, the id being public. A match spends the row by the one compare-and-set, a spend another presentation took being the refusal. Then the account's standing and the minting session's row are read as the code form reads them, each failure the refusal with the row spent, and the exchange mints as the code form does.

The held form's `mint` also takes `device`, the device poll of `turnzero login --device`. There the kind gate reads the newest device row of the bearer's S256 hash, whatever its end, and judges it as it judges a row named by its id. A device row named by its id is the one refusal, nothing spent. The poll reads device rows alone, so a `token request` or `authorize` row under the same challenge is never redeemed by it.

The device poll before the Approve finds no device row of its challenge, and is answered 400 `authorization_pending` with a `detail` saying no one has approved the sign-in, nothing was minted, and to poll again in five seconds until the request's `expires_at`. The answer writes no action record and no meter row, as a bearer that resolves to nothing writes none, since the poll names no row and repeats while it waits. `authorization_pending` is a row of `schemas/wire_errors.json` that this statement and MCP-02 answer (MAPI-15).

The plane mints the token where the verifier's S256 challenge is the recorded challenge, the account is not suspended, and the minting session's own row stands unrevoked, unexpired, and not behind its account's generation. That one read covers sign-out everywhere, `revoke_token` with `connection`, and the client's own revocation at the revocation endpoint (MCP-02). It also covers a device's sign-out, a passkey change's revert, and the session's expiry.

The exchange also reads again what the mint read: an application-scoped code's application, an `issues` code's space, `tztrack` profile (ACB-L0-89), and label, a `tzmesh` code's profile, a `tztrack` code's profile, and a product code's origin. Where the account no longer holds the application, the space, or either profile, or an unrevoked token has taken an `issues` code's label since the mint, the exchange answers the standing mint's refusal. That is `no_such_application`, `space_not_owned`, `blueprint_required`, `tzmesh_required`, or `invalid_request`, the code spent and nothing minted. A fault reading the space is answered as the standing mint answers it, and any other fault is the dispatcher's internal failure.

This paragraph adds the `test_end_users` grant's label rule (MAPI-14) beside the `issues` one. The code's mint reads it from the account's token rows for the code's scope before anything is written, a taken label refused in the mint's words with no code minted. The exchange meets it again at the store's insert, a label taken since the mint refused `invalid_request` with the code spent and nothing minted.

It mints with the recorded properties and the marker, writes the token's identity on the code's row, and answers 200 with `token`, the identity beside the same shape, and `value`, to that one caller, and no later read shows the value.

A product code's exchange mints the signed form MAPI-03 states. The management service holds no signing key (SEC-L0-07), so the exchange writes a single-use ticket of kind `product_token` into the shared tickets store (PLD-L0-67), naming the account, the product, the label, the level `admin`, the token's identity, and its expiry. It posts the ticket with the account to the accounts service's route `/accounts/v0/<product>/token`, which takes the ticket once, signs under the product's realm, and answers the value. The route refuses a ticket absent, spent, expired, or naming another account or product 403 `product_ticket_refused`, and a build naming no origin for the product answers 404 `not_found`. A process holding the keys signs in-process and writes no ticket, as the erasure walk's member does (ACB-L0-47).

The exchange stores the value's hash and the product on the token's row and answers the value once, as for every token. The route's 503 `realm_keys_unready` is answered by name at the exchange, the code spent and nothing minted, and the person mints again. The ticket lives one minute, is discarded with the answer, and is purged with the table's other kinds (PLD-L0-67).

One refusal answers every other state: 403 `token_code_refused`, alike in name, status, and detail, each answer carrying its own `reference` (MAPI-10). The states are an unknown, spent, expired, or ended code or device row; a body naming more than the verifier; an unmatched verifier, or one outside its form; and a code of a suspended account or an ended session. So is a bearer of a grant's form that resolves to nothing there. A mismatch, or a verifier outside its form, spends the code, so a copy presented without the verifier mints nothing, and the person's own line is then refused and told to call `mint_token` again. The detail says the code cannot be used, being unknown, expired, or already presented, its verifier unmatched, its account suspended, or its session ended, that nothing was minted, and the remedy. `token_code_refused` is this statement's row of `schemas/wire_errors.json` (MAPI-15).

Every presentation at the exchange form and the held form, a device poll among them, counts in its source's admission window ahead of the lookup, whether or not the plane holds the code (PLD-L0-67). So the gate's 429 `rate_capped` alone precedes the spend and leaves a found code unspent. A transfer grant or a secret grant presented there is answered as MAPI-03 states and stays unspent. Elsewhere a code is no credential: on every other management action, on `mint_token`'s other forms, on the MCP surface, and on the storage and egress wires it is answered as a value of a grant's form that resolves to no credential is (MAPI-03), unspent.

`code_verifier` is a wire-only member (MAPI-08): an MCP call naming it beside a challenge is refused 409 `local_route_required`, and a wire call to `mint_token` naming it under any credential but a token code 400 `invalid_request`, nothing minted. `store_secret` with `replace: true` reads it under a `provision` grant alone (SEC-L0-19). An MCP call naming it with no challenge meets the shape's own refusal first. A token code holds no destructive class (MAPI-12). `mint` is the wire's alone the same way, an MCP call naming it refused 409 `local_route_required` and a wire call under any credential but a token code or a verifier at the held form 400 `invalid_request`, nothing minted. Under a token code a body naming `code_verifier` beside it is the code form's refusal, the code spent; one naming no `code_verifier` resolves to no credential, unspent. `completion` is a tool argument, carried over MCP and the wire alike (MAPI-14).

A code ends with its one presentation, its expiry, a later `mint_token` by the same session under the same label, a device row excepted, and the account's `sign_out_everywhere`, a passkey change's revert, and suspension; the account's erasure removes the rows (PLD-L0-66). `revoke_token` with `connection`, the client's own revocation at the revocation endpoint (MCP-02), a device's sign-out, and the session's expiry write no end on the code. The exchange refuses such a code by its read of the session's row. A reinstatement brings no ended code back. The daily pass's step `token_codes_purged` deletes each code a day past its expiry (PLD-L0-67).

The mint's action record names the session's kind and the code's identifier and holds no part of the answer. The page's mint writes the same record and the same control-plane line, its session kind the browser session's. The exchange's record is attributed to the owning account with the code's kind and identifier, and names the token minted. A refused presentation of a code the plane holds is recorded against its identifier, and one of a value it does not hold with no value. The mint and the exchange each write one control-plane line, the mint's naming the code's identifier and the exchange's the token's and the code's (MAPI-14). No code, verifier, or token value stands in any record, event, or log line, and no hash of a refused value is logged (system:SCRT-L0-02); the challenge may stand on the code's row, since it is public.

At the launch population (PLD-L0-74) the `token_codes` table holds about a day's mints, tens of thousands of rows, and `minted_tokens` gains one live row per authorized computer and origin, about 900,000 rows inside the thirty-day retention at 300,000 accounts. The marker is one nullable column with no index, read as a token is read today. The pass's delete reads `expires_at`, which no index serves, an index owed at the next order.

The device mark is one boolean column with a constant default, and the partial index on a device row's challenge and creation holds the device rows alone, a small share of the table. A waiting command polls every five seconds, about 720 polls in its hour, each about three statements: the guard's two lookups and the one probe of that index. At 300,000 accounts, if one in a hundred signed in by device each day and waited ten minutes, the polls would ask about 12 statements a second, an estimate. At two million accounts the same share asks about 80, each an index probe on the control database, which needs no change of unit.

MAPI-19: The `connection` resource is a signed-in tool's OAuth 2.1 refresh family (API-L0-21; MCP-10), one per sign-in a registered client completed, and the account grain holds its two acts. `list_tokens` (observe) answers the acting account's live connections. Each row is its identity, its client, the instant of the sign-in that opened it, its last renewal or null, and its expiry, and never a credential value or hash. The listing is idempotent and answers GET as every observe row does (MAPI-10). `revoke_token` with `connection` (reversible) ends the connection that member names: the family's refresh credentials are deleted and its access-token session rows revoked, so the tool is refused at once on the management surface, the MCP endpoint, and the wires alike. It touches no other connection, cookie, or minted token. A `connection` no live family of the acting account carries is refused 404 `not_found`, another account's among them.

`list_tokens` and `revoke_token` with `connection` are callable by the session credential and by the browser session (MAPI-03; MAPI-05), and by a minted token as MAPI-03 admits an account act. The Connected AI tools page's Connected tools section lists and ends the rows (WEB-L0-21), and the home reads the list for its card alone (WEB-L0-17). Neither is grant-marked (MAPI-09). Each end writes one line into the control plane's own diagnostics carrying the account, the client, and the family, never a token (system:LGS-L0-16).

The row `sign_out_everywhere` (reversible), on the `account` resource under the same callers and no grant mark, ends every session and every connection of the account at once and answers `sessions_ended`, `refresh_rows_deleted`, and `exchange_tokens_revoked`. The last counts the tokens an authorization exchange issued the account that it ended, the `tzmesh` exchange's and those the retired client `turnzero-blueprint` was issued (MCP-02; ACS-L0-18). The site's Sign out ends that browser's session alone.

A token a narrow grant bounds is answered its tokens alone, no connection among them (MCP-08).

MAPI-15: The refusal names are enumerated. Every refusal name a surface of the plane answers is listed once in `schemas/wire_errors.json` beside this document. Each row carries the surfaces that answer it, the HTTP status where one status is fixed across every site, and the statement that owns the behaviour. It also carries one clause saying when it is answered and one clause saying what the caller does next, the row's remedy, written by the change that adds the row. The surfaces are the management actions on their routes and through the tools that surface them (MAPI-08), and the MCP server's own challenge. The others are these:
- object storage;
- the egress gateway;
- the push service's send route;
- the email service's send route;
- the accounts service's realm surface;
- the builder sign-in;
- the serving router;
- the deploy command's progress read, the catalogue's `deploy_progress` (PLD-L0-86).

This paragraph qualifies the catalogue's refusal rules while the suite's closed list of refusals answered by the plans path alone holds a name. A refusal on that sorted closed list may remain outside the catalogue. Each listed name must still be answered by the source and absent from the catalogue. Any other name answered without a row still fails the suite. The exception ends when the list is empty.

Four more surfaces answer names of the list: the egress tunnel seat (`egress_tunnel`), the logging ingest (`logging`), the runner harness inside every application container (`harness`), and the documentation trees' machine files (`documentation`).

Where the refusal's body on the management action surface carries members beyond the six base members (MAPI-10), the row carries a `members` object giving each member's name a JSON Schema fragment that types and describes it. The published refusals page reads both clauses and the members from the row and derives none of them. Each clause is written in sentences of fewer than 45 words, because the page carries them as table cells under the documentation's prose bound, a member's description held to the same bound for the same reason.

A row's `members` state the body the management action surface answers and nothing of another surface's body under the same name, so a row that does not name that surface carries none. The rows and the schema generated from them state the management action surface's refusal bodies alone. The body another surface answers under a name of this list is that surface's owning statement's to state, in the shape the surface answers, and no row, schema, or description of this catalogue holds it to the management action surface's shape.

The rows are the members' one home. A fragment uses `type`, `items`, `properties`, `pattern`, and `description` alone, through its nested fragments, and never an enumeration, a constant, a format, or a required list. It never uses them because a closed vocabulary in a fragment would make every later value a change of the body's shape and because every member is admitted and none required. A member that may be null says so in its `type`, and a nested object declares the properties the platform answers and stays open.

The list is derived from nothing and reviewed onto nothing. A test in the platform's suite extracts the names from the source by the call forms the surfaces use to put a name on the wire and holds the two sets equal. So a name the source answers that the list lacks, and a row the source no longer answers, each fail the suite. A name absent from the list is a defect in the change that added it, closed by adding the row in the same change, never by excluding a real wire form from extraction. When the implementation introduces another way to carry a refusal name on the wire, the extractor covers that form and the catalogue gains any new names in the same change.

The JSON body shape stays MAPI-10's (`schemas/wire_error.schema.json`), whose member region is generated from the rows' `members`. The suite holds each row's members to this form and each declared member's name to a key the platform source writes at a site that builds that refusal's body. So a member the rows declare and no site of that refusal still writes fails it, as a row the source no longer answers does. This catalogue includes the JSON `error` member's values and standard OAuth `error` parameters in WWW-Authenticate challenge headers and authorization redirects; it does not impose the JSON body shape on those standard protocol fields. This is MAN-12's named-refusal discipline made a check. Within a contract version the list grows and never shrinks: retiring a name is a new contract version (MAPI-02).

One case stands beside that rule while MAPI-02's under-one-hundred-accounts clause stands. A name the source stops answering because its cause has left the platform may leave the list within version 1, recorded as MAPI-02 records a use of that clause, with the account count read at the change.

The members' evolution is MAPI-02's and no rule of this statement's own. While its under-one-hundred-accounts clause stands, a member added to a row, a member removed from one, and a fragment's typing changed, its `type`, `items`, `properties`, or `pattern`, are each a change of the body's shape, recorded by MAPI-10 as a use of that clause. A description's wording is a content change that moves the version and no use. Once it lapses, a member added is a new optional field, and a member removed or a fragment's typing narrowed is a new contract version.

A row's owner is the one statement that states its behaviour. A name several statements answer names none, its surfaces and summary saying where and why: `access_denied`, `account_picture_not_yet_served`, `account_picture_unavailable`, `authentication_required`, `authorization_pending`, `browser_session_required`, `invalid_request`, `not_configured`, `not_found`, `no_such_application`, `origin_not_admitted`, `publish_incomplete` and `publish_not_forward` are such names. A row whose behaviour no statement states yet carries none until a statement states it.

The `builder_sign_in` surface also includes `/accounts/v0/tzmesh/site-token` (ACS-L0-18). It answers `origin_not_admitted` for an absent or unmatched origin, `account_suspended` for a suspended account, and `access_denied` where the one rule answers no `tzmesh` profile (ACB-L0-76). The catalogue's rows include that surface and those causes; the route's bodies remain ACS-L0-18's, under the surface-shape rule above.

The `dashboard_picture` surface is `GET /dashboard/account-picture`, the dashboard credential's picture read (WEB-L0-27). Its four ordinary refusals carry JSON `error` and `detail`; its admission refusal also carries `contract_version: 1`. A thrown error returns the router's 500 HTML failure page, not a refusal name. WEB-L0-27 owns these response bodies.

MAPI-13: The running build states its identity on the health read. The artifact carries a build stamp written at bundle time — the source commit, whether the tree was dirty, and the build instant — as a stamp file beside the bundle. `GET /healthz` answers it as `build` beside MAPI-02's `contract_version`. Beside the stamp's three members, `build` carries `bundle_hash`, the SHA-256 of what the process's image copies: the one bundle file for the serving router and the tunnel seat, and for the plane the `dist/` tree its image copies whole. For that tree the hash reads every file under the folder holding the bundle, each relative path joined with `/`, the paths sorted by bytes, each path then its file's bytes fed to one hash, `build.json` and the bundle's source map excluded.

`bundle_hash` is read at the process's boot from the file it runs as `harness_hash` is, and it is null where the process does not run from its image's file. Beside `build`, `/healthz` answers `harness_hash`, the SHA-256 of the runner harness bundle beside the running bundle, the harness the platform bakes into every application image it builds (PLD-L0-63). A source tree with no stamp answers null members, never an invented value, and a process with no harness bundle beside it answers `harness_hash` null the same way.

Beside `build`, `/healthz` answers `wire`, the plane's served wire: for each served schema file `schemas/served_context.json` names that carries a top-level `version`, that version keyed by the file's name without `.json`, composed once at the process's boot. It is read by the turnzero command once per run, before its first request, to check the plane it addresses, and by the command's publish workflow, which checks the command's declaration against each estate's wire before it publishes.

Beside `wire`, `/healthz` answers `command_latest`, the turnzero command's latest release as `<major>.<minor>.<patch>`, where the plane knows it. It is the release the estate's tag names in the public npm registry's dist-tags, `latest` on production's origin and `next` on any other, a pre-release counted as the release it is cut from. A serving process that mounts the management set reads it at most once an hour beside the answer that asks, never per request, each read bounded at three seconds. A failed read keeps the last value read, and where no read has succeeded the member is absent. The command reads it with `wire`, before its first request, so it can name a newer release before any call meets the floor (PLD-L0-94; PLD-L0-109).

Beside `command_latest`, `/healthz` answers `opened`, the products' openings as the process last read the served settings (PLD-L0-76). `tzmesh` and `tzteam` are each true where the setting `invite_only_products` did not name it, and `tztrack` is true, every account holding it (ACB-L0-76). It is the reading the process's own setting reader holds, and the health read starts none, so where no reading has succeeded the member is absent. The site publish reads it from the estate it publishes to, so the open trees it lists follow the estate's own setting (PLD-L0-75). Where the member is absent, or does not name a product, the publish reads that product as the default invite-only list opens it.

The identity answers on that one anonymous read rather than riding every exchange. It also answers on two aliases the edge's standing routes carry to the services its default route does not reach: `GET /accounts/v0/healthz` on the accounts mount set and `GET /logging/v0/healthz` on the gateways mount set. Each answers the body `/healthz` answers, read through the edge under the origin lock's check where `/healthz` itself is exempt (PLD-L0-67). So two builds of one contract are distinguishable to any caller at the cost of one call, and a deploy's completion is the served identity changing to the deployed commit (PLD-L0-65; the handshake SVC-L0-11 asks of a customer's backend, kept by the plane itself).

The build also states its readiness on `GET /readyz`: one statement per database pool the process holds. It answers 200 with `ready` true, `pools` naming each pool with `ok`, and `unapplied` 0, or 503 with `ready` false, `pools` naming the pool that failed, `unapplied` counting the migration files the ledger lacks, and `detail`. The answer carries them beside MAPI-02's `contract_version` and `build`, the member `/healthz` answers, so the one readiness read carries the process's identity.

On the accounts mount set the answer also carries `realm_keys`, ready once the realm key-encryption key is unwrapped (SEC-L0-07). A process holding no pool answers ready with an empty `pools`.

On a process mounting the gateways set alone, a control pool whose statement failed while the credential cache holds an entry within its stale ceiling answers 200 with `ready` true, that pool `failed` in `pools`, and `serving_stale` true. The wires answer from the held entries (PLD-L0-67's cache rule). The migration status read fails with that pool and refuses nothing while the answer is `serving_stale`, whose `unapplied` reads 0 whether or not a ledger was read, and every other failed statement refuses as stated.

On that process the control pool's check and the status read each have a bound under the host's probe timeout, so a connection that hangs does not outlast the probe. A control pool past it reads as failed. A status read past it refuses only until the process has read the status clean. After a background answer names an unapplied file, it refuses again until the process reads clean. Otherwise a saturated pool does not take a busy replica out of traffic.

On every process, a migration status reading with no unapplied file is held with its instant. Until that reading is cleared, a readiness probe reads no ledger and waits on no status read; `unapplied` is 0. A probe at least five minutes after its instant starts one background read, at most one counted in flight per process. A read still open five minutes after it started is no longer counted in flight. A late answer applies unless a read started later has already answered. A clean answer renews the instant; an answer naming an unapplied file clears the reading, so the next probe reads the ledgers under the preceding rules. A failed background read refuses nothing, writes `readiness migration status read failed` at `info`, and renews the instant so another full interval passes before a retry.

On a build that mounts the gateways set, `GET /healthz` also answers `caches`: for each gateway cache, `credential` and `rows` (PLD-L0-67), the positive and negative entries held and the hits, misses, and stale serves counted since the process started, read from the process alone. The health read stays the identity read and touches no store, so a host's liveness probe and its readiness probe ask different questions (PLD-L0-67).

The process binds its listener before it builds its routes. A connection attempted before the bind is refused at the socket. A request accepted after the bind and before startup completes, a liveness or readiness probe included, is held unanswered until the routes are built and the pre-serve work the entry runs for its mount set has completed (PLD-L0-67). That work is the timers' start and, on the management set, the first sweeps; the request is then served by the built application. Where that work fails after the bind, no held request is answered, each held connection is destroyed, the listener closes, and the startup call fails with the error, which ends the executable's entry.

The listener keeps an idle connection for 290 seconds before it closes it, and its headers timeout stands five seconds above that. So where the ingress in front of the plane pools an idle connection for less, the listener never closes one the ingress still pools.

MAPI-16: The synthetic estate is six grant-marked rows of the enumeration under `grant: synthetic_estate` (MAPI-09): a seed and a purge, both reversible, and four observe reads, of a purge, of a sign-in code, of setup mail, and of an account's state. Its grant is a third grant beside the destructive class and `super_admin`, minted on MAPI-14's terms, the grant the compat harness's and the live tests' tokens carry. The estate is the company's own act on the company's own test fixtures, naming no customer account (the synthetic account kind the accounts and billing PRD states; API-L0-12).

The grant bounds the token that carries it, at the platform's two seams. So does `publication`, the fourth grant, which marks the two publish rows (MAPI-09). It is minted on MAPI-14's terms, the one grant the publisher's token carries (CRD-01). So does `feedback_queue`, the fifth, which marks no row and is the one grant `read_feedback` and `settle_feedback` name under `admits` (MAPI-18), the one grant the feedback queue's triage token carries.

So does `issues`, the sixth, a space grant any session of the account gives for one space it holds (MAPI-14), which marks no row and is admitted on `list_tokens` and `relay_issue_act`. So does `synthetic_seed_purge`, the seventh, a staff grant minted on MAPI-14's terms, which marks no row and is named under `admits` on three of the estate's rows. With `tzmesh` and `tztrack`, the two paragraphs after this one, and `device_sign_in`, the session bound stated after them, the eight are the bounding grants.

`tzmesh`, the eighth grant, is a product grant any session of an account holding the `tzmesh` profile gives (MAPI-14). It marks no row and is named under `admits` on `list_tokens` and `submit_feedback`. Its reach into its product's own service is the signed form MAPI-03 states. The `tzmesh` service verifies each token by signature with no call to the plane per token it admits; it reads the key set the plane publishes and the plane's revocation list from the plane on its own schedule, the list once a minute (MCP-02). What the service admits the token to is the `tzmesh` member's, stated in its own requirements. A token it bounds is admitted to `list_tokens`, to `submit_feedback`, where it files a report, and to the anonymous rows. It is refused every other row 403 `tzmesh_bounded`, the refusal's members the same.

`tztrack`, the ninth grant, is a product grant any session of an account holding the `tztrack` profile gives (MAPI-14), and the tzTrack exchange issues (MCP-02). It marks no row and is named under `admits` on `list_tokens`, `list_issue_spaces`, `submit_feedback`, `share_space`, `set_ai_passes`, `list_space_members`, `create_space`, `delete_space`, and `rename_space`. Its reach into its product's own service is the signed form MAPI-03 states, which that service verifies as the `tzmesh` service does, reading the `tztrack` key set and revocation list (MCP-02; system:XIT-24). What it admits the token to is the `tztrack` package's to state.

A token it bounds is admitted to the anonymous rows and to the rows of those nine it reaches: all nine for a token a sign-in's exchange issued, and `list_tokens`, `list_issue_spaces` and `submit_feedback` for a token `mint_token` minted. It is refused every other row 403 `tztrack_bounded`, the refusal's members the same, its `admitted` naming the rows that token reaches.

`share_space`, `set_ai_passes`, `list_space_members`, `create_space`, `delete_space`, and `rename_space` admit a token a sign-in's exchange issued, a person present, the device grant's among them. They refuse a token `mint_token` minted 403 `tztrack_bounded`, the refusal naming the three rows that token reaches. `delete_space`, the one destructive row of the nine, reads that refusal in its description, after the class gate, so a minted token holding no class is refused `destructive_class_required` first (MAPI-12). A test over the enumeration holds that the destructive rows a `tztrack` token's bound admits are `delete_space` alone, and that each is among the six, so the class a sign-in's token takes at its minting (MAPI-14) reaches no other row.

`device_sign_in`, the tenth grant, bounds no minted token. It bounds the builder realm's device-grant session, issued for the plane's own resource or a customer MCP address's (MCP-02; MAPI-14). The bound stays on the session's binding through renewal (MCP-10). It marks no row. The rows whose `admits` names it are `start`, `read_account`, `read_context`, `read_documentation`, `read_approval_status`, `submit_feedback`, `create_space`, `share_space`, `set_ai_passes`, `list_space_members`, `delete_space`, `rename_space`, and `list_issue_spaces`. A plane row joins that list only by a revision of this paragraph naming it, with its `admits` mark. A test holds the marked rows to this list.

A session it bounds is admitted to those rows, to the anonymous rows, and to the forwarded rows of the products its account holds (MCP-14). It is refused every other unmarked row 403 `device_sign_in_bounded`, the refusal's members the same. Among those rows are `mint_token`, `export_account`, `link_identity`, `delete_account`, `sign_out_everywhere`, the token and connection rows, and every row marked `product: cloud`. The session holds no `super_admin`, so every grant-marked row refuses it 403 `grant_required` naming the row's grant, an operator's account included (MAPI-09; MAPI-14's order). On the data planes it reaches no declaration, as the paragraph on the data planes states.

A minted token whose grants hold one of them and not `super_admin` is bounded by it exactly as this statement states for `synthetic_estate`. It is admitted the rows its grant marks, the rows the enumeration marks `admits` with its grant's name, and the rows marked `access: anonymous`. It is refused every other row under the grant's own name, `synthetic_seed_purge_bounded` for the hosted trial's, `publication_bounded` for the publisher's, `feedback_queue_bounded` for the triage token's, and `issues_bounded` for a token the space grant bounds, the refusal's members the same.

A mint gives a token that takes no `super_admin` at most one of the bounding grants, and a request naming two is refused 400 `invalid_request` with nothing minted (MAPI-14). So no token carries two bounds, and a session carries at most the device grant's. A stored row that did would be bounded by the first of them in the order the predicate reads them, `synthetic_seed_purge`, then `synthetic_estate`, then `publication`, then `feedback_queue`, then `issues`, then `tzmesh`, then `tztrack`, then `device_sign_in`, its reach the narrower for it. `synthetic_seed_purge` stands first because its three rows are among the estate's, so a row naming both meets the three alone. No row of the enumeration marks `admits` with `publication`, so the publisher's token reaches its two rows and the anonymous rows and no other, `list_tokens` and `read_account` among the refused.

The triage token reaches `settle_feedback`, `read_feedback` in every form, and the anonymous rows and no other, `submit_feedback`, `list_tokens`, and `read_account` among the refused. So a report it reads can turn it to no filing and to no act beyond the queue. A token the space grant bounds reaches `relay_issue_act` for the one space its grant names, `list_tokens`, and the anonymous rows and no other, the space and the level judged at the relay's handler (the issue service PRD's relay row). An act above its level is refused `issues_level_refused` naming the level and the acts it admits, so a token a teammate's clone or a build step holds reaches one space of its account at one level and nothing else.

It is admitted to the rows the enumeration marks `admits: ["synthetic_estate"]`, two rows, ten rows in all with the eight above. One is `list_tokens`, the observe read under which every consumer of such a token finds its own row's expiry. The other is `submit_feedback`, the filing of a report into the company's own space of the issue service (MAPI-18). That filing names no customer account and reaches no customer's data, the ground the operator signal's row stands on (MAPI-17), so a company harness files its findings under the token it already holds. Such a filing may cite the reference of a call an account of a batch that credential seeded made, the stamp and the daily pass's join reading under that account (MAPI-18; PLD-L0-67).

The token is also admitted to the rows marked `access: anonymous` (MAPI-11), which lie outside the bound and answer a bounded token as they answer every connection, the credential-filtered view where MAPI-11 gives one. Every other row refuses it 403 `synthetic_estate_bounded`, `read_documentation` among them, which carries no anonymous mark. The exception is where a refusal that answers every credential ahead of the bound answers it first. The approval row's `browser_session_required` (MAPI-05), a page-only row's refusal of an `Authorization` header (MAPI-03), and `not_yet_provisioned` on a row whose implementation has not arrived (MAPI-10) are among those refusals. The bound's refusal carries a `grant` member naming the bounding grant. Its `admitted` member names the rows the grant and the `admits` mark admit, the anonymous rows outside the bound and named in the row's clause.

Under that grant a repeat is answered only where the batch or the purge is the caller's own. A seed repeating another credential's `request_id` is refused 400 `invalid_request`, and a purge doing so 409 `account_outside_batches`. Under `synthetic_estate` the read and both repeats answer every caller, the harness's tokens sharing one operator account. The token's own row stands in its owner's `list_tokens` answer, which the token itself does not read.

The `admits` mark is the enumeration's own member on MAPI-11's pattern, this statement's to own. The bound's gate runs after the grant gate, under which a grant-marked row that does not admit the token keeps `grant_required`, and before the destructive-class gate (MAPI-14). The grant gate admits a token on a grant-marked row where it holds the row's grant or `super_admin`, or where the row's `admits` mark names the grant that bounds it (MAPI-09). One exported predicate over the enumeration's three marks, the grant, the `admits` mark, and the access mark, serves the gate, the MCP listing (MCP-08), and the `admitted` member, no list kept beside the enumeration (MAPI-11). One exported predicate likewise decides the grant gate and the listing's grant rule, reading the token's bound and never another grant it holds.

On the data planes the bounded credential reaches no declaration of the account. Object storage refuses it 403 `area_scope_refused` on a route of a declared area and at a minting request the route would otherwise admit. The egress gateway refuses it 403 `upstream_scope_refused` on a call naming a declared upstream. The refusals that answer ahead of each surface's reach rule answer it as they answer any account-wide credential. With those and the two scope refusals, neither surface serves it. The two refusals carry the bodies those surfaces' owning statements state (OST-L0-03; EGW-L0-08). So every consumer of the estate presents the seeded account's own token on the data planes and never the grant-carrying one. The same two refusals answer the hosted trial's token, the publisher's token, the triage token, a token the space grant bounds, whose acts are management actions alone, and the session the device grant bounds (MCP-02).

A token minted with a bounding grant and `super_admin` is `super_admin`'s and is bounded by nothing (MAPI-09). And `all: true` on the purge, the purge of a batch another credential seeded, and the code read and the state read for any synthetic account are `super_admin`'s (MAPI-09).

The seed takes `count` (1 to 100), an optional `label_prefix` (`synthetic-` by default), the required `token_expires_in_days` (1 to 3650), an optional `request_id`, refused `invalid_request` where it opens the reserved `first-sign-in:` (below), an optional `sign_in`, and an optional `products`. The last, on the invitation member's vocabulary, is read for the invite group alone, a `tzteam` among it joining the group, and the seed writes no product row (ACB-L0-79; ACB-L0-77; ACB-L0-76). The seed creates `count` synthetic accounts and mints one account-scoped token per account through `mint_token`'s own code path: no grant unless `token_grant` names one, the given expiry, the label `<label_prefix><n>`. It answers each token value exactly once, as `mint_token`'s wire exchange does (API-L0-05; MAPI-23). It writes one action record per created account and per minted token naming the calling credential, the operator's session or the harness's token (MAPI-06). The tokens are ordinary minted tokens, shown by `list_tokens` and ended by `revoke_token`.

`tools_plan`, an optional member, is one of `free`, `tools`, and `tools_plus`, and `app_hosting`, an optional member, is a boolean, each refused `invalid_request` otherwise. A seed naming either writes each created account's `tztrack_subscriptions` row, state `active` and no provider identifier, and its feed row in that row's transaction (ACB-L0-92), so a proof of a per-person limit holds a fixture on a plan before collection is built. A value left out reads as its column's default, and a seed naming neither writes no row. A repeat creates nothing and writes no plan. The purge removes the row with the account.

`token_grant`, an optional member, is `tztrack` alone; any other value is refused 400 `invalid_request`. With it, each account's one token is minted through `mint_token`'s own mint with the `tztrack` grant, level `admin`, and the seed's label. Its value is signed under the product's realm (MAPI-03; MAPI-14). It requires `token_expires_in_days` 1, `sign_in` absent or false, no `access_link` member, and an estate naming a tzTrack origin. A failed condition refuses 400 `invalid_request` before any account is created. Under `synthetic_seed_purge`, the member instead refuses 403 `synthetic_posture_refuses`, naming `token_grant` as the bound and that grant. Without the member, the seed keeps its token with no grant.

`access_link`, an optional member, is admitted under `super_admin` alone and refused 403 `grant_required` naming `super_admin` otherwise. It requires `count` 1, no `sign_in`, no `tools_plan`, and no `app_hosting`, refused `invalid_request` otherwise, since the account is a real person's. It takes `sign_ins`, 1 to 50, 15 where absent. The wire answer carries the link once beside the token, and a repeat answers none (ACS-L0-22). Over the MCP surface a seed naming `access_link` is refused `invalid_request`, naming the wire route, and creates nothing.

Every seed, one without `request_id` too, records a batch under a server-minted identity answered as `batch`. The batch row carries the expiry instant fixed at seeding, `swept_at`, and the nullable `seeding_credential`, a minted token's identity and null for a session seed. The expiry instant is the posture's account lifetime from the seeding instant, so a posture change moves new seeds alone and a stress expiry never turns twenty-one days into three mid-test. With `sign_in: true` the seed binds, per account, the second identity ACB-L0-79 states — the `email` identity at the reserved fixture domain `synthetic.turnzero.ai` — in the seed's own transaction beside the `synthetic` identity, and the answer carries, per account, `email`.

This paragraph qualifies the batch's expiry fixed at seeding and the account lifetime cell: an access-link batch's expiry is ACB-L0-87's, never the posture's lifetime.

A repeat carrying the same `request_id` from the same operator's account answers the same batch's identity, account ids, labels, and, where the seed carried `sign_in: true`, each account's `email`, without token values. The repeat creates nothing, so a retried call never double-creates, and a batch whose values were lost is purged and seeded again.

The purge takes `accounts` (account ids) or `all: true`, an optional `request_id`, and an optional `drop_metering`. Where any named id is a standing account that is not synthetic, the purge refuses the whole request 409 `account_not_synthetic` and deletes nothing. Under either synthetic grant alone it admits an account only where its batch's `seeding_credential` equals the caller's own identity, refusing the whole request 409 `account_outside_batches` otherwise. That refusal names the grant that bounds the caller, and so does the refusal of `all: true` where the posture admits `all: true`. Under `synthetic_seed_purge` the scoping is read first, so an id outside the caller's batches answers `account_outside_batches` whatever account it names. So an account no batch names, a batch a session seeded, and a batch another credential seeded are purgeable under `super_admin` alone.

The purge deletes the account's access link.

A second purge naming an account a running purge already holds joins that purge. The account is walked once and its state read from either purge, the joining purge's own state covering the accounts it walked itself. A unique index over the live account rows holds the join across replicas. A joining purge that asked the metering drop raises the walking purge's own `drop_metering`, which its runner reads again before each walk. So the walking purge drops the metering for every account it walks after the join. An account whose walk was in flight at the join may keep its rows until a repeat purge under `drop_metering: true`.

An account already gone completes with zero removals, so a repeat purge of purged ids is a no-op. A walk that stops at a failing member ends the account `failed` with the error and the receipts written before the failing member (the estate receipts, the application receipts, and the failing member's name). A repeat purge naming that account runs the walk again, every member idempotent.

A purge interrupted by a platform restart ends `failed` with the outcome `interrupted` under the rule deploys follow, and a repeat converges. Under that rule the shutdown handler finishes the runs the process holds. An account whose walk was in flight at the interruption still ends `completed` with its receipts where the walk returns. A sweep on the stale-deploying sweep's cadence finishes a running purge whose heartbeat is older than the deploy's stale bound. A store failure of the runner's own ends the purge `failed` with the outcome `runner_failed`. A repeat carrying the same `request_id` answers the same purge.

With `drop_metering: true` the purge also removes each account's meter rows, so the test leaves no trace in platform usage. The meter rows are its usage events, its storage and egress call rows, and its applications' traffic, verification rollup, and database sample rows. The action records stand, because MAPI-06 makes the operational record append-only. The realm event log's rows stand, because no action removes them (ACS-L0-02).

The estate runs under a posture, one value of the control plane's setting `SYNTHETIC_ESTATE`: `off`, `compat`, or `stress:<YYYY-MM-DD>`. The date is the stress posture's expiry, after which new seeds take `compat`'s cells while the purge and every other ceiling read the value's posture. `on` is an alias of `compat`, and any other value reads as `off`.

The ceilings are constants this statement states and the code holds, never settings rows, so no runtime surface raises them. They are shared: a seed counts against them whichever of the two synthetic grants its credential holds. Each is stated as its `off`, `compat`, and `stress` cells with the refusal it names. Standing synthetic accounts are 0, 25, and 6,000, the seed refusing 409 `synthetic_ceiling_reached`. Standing synthetic applications, and those on a paid plan, are 0 and 0, 50 and 10, and 12,000 and 12,000. They are refused 409 `synthetic_ceiling_reached` at `create_application` and, under `usage`, at `set_app_size` for a synthetic-owned application. Accounts one seed call creates are none, 25, and 100, the seed refusing 403 `synthetic_posture_refuses`. Token expiry the seed admits, in days, is none, 3, and 30, the seed refusing 403 `synthetic_posture_refuses`.

Account lifetime, in days, fixed at seeding and the sweep purging at its end, is none, 3, and 21, with no refusal, the catch-all's bound under `off` being `compat`'s. Accounts seeded per operator account per UTC day are 0, 1,000, and 6,000, the seed refusing 409 `synthetic_ceiling_reached`. `all: true` on the purge is refused, refused, and admitted to `super_admin` alone, the refusal 403 `synthetic_posture_refuses`, so a purge under `compat` names the accounts it removes. The posture's expiry is none, none, and the date in the value. The seed reads its two ceilings by one call's count under no lock. So seeds admitted concurrently may together pass a ceiling by at most their counts, corrected at the next seed's read and by the lifetime sweep.

The `synthetic_seed_purge` grant has a standing ceiling of its own, a constant the code holds beside the cells. Under it a seed is refused 409 `synthetic_ceiling_reached`, naming the ceiling `standing_accounts_per_credential`, once sixteen standing synthetic accounts are ones the calling credential seeded. The count reads the batches that credential seeded against the standing synthetic accounts, ahead of the posture's own ceiling. An account whose purge is still in progress counts until its walk removes it, so the count errs closed. It is read under no lock, so two seeds admitted at once may both pass it. A token minted to replace another starts at zero while the lifetime sweep purges the old one's batches. So a disclosed copy holds at most sixteen of the standing accounts. A `synthetic_estate` token and a `super_admin` credential meet no such ceiling.

An account seeded under that grant holds one application at `shared-0.5gb`, the size stored as the Free plan. A creation at `shared-1gb`, or a move to that size through `set_app_size` under `usage`, is refused 409 `synthetic_ceiling_reached` naming `paid_applications_per_account`, under every posture. Under `plans`, a second application meets the Free plan's own limit. Under `usage`, a second creation refuses 409 `synthetic_ceiling_reached`, naming `applications_per_account`, under every posture. The account is told by its batch's seeding credential, a token the grant bounds, whether or not that token still stands. So a disclosed copy's accounts take none of the estate's paid-plan places.

The two writes, the seed and the purge, are admitted only while the posture is not `off`. While it is `off` they refuse 403 `synthetic_estate_disabled` before any other check. The dispatcher's switch gate runs ahead of the credential-kind, scope, grant, bound, and destructive-class gates, so a customer's session meets this refusal and not `grant_required`. Their rows, marked `switch: synthetic_estate` in the enumeration, are listed as tools while the posture is not `off` and unlisted while it is. They are listed only to a connection whose credential holds `synthetic_estate` or `super_admin` or is bounded by `synthetic_seed_purge`, both rules MCP-08's. The listing is derived from the enumeration's own marks, the credential, and the setting, and no list is kept beside it (MAPI-11).

The lifetime sweep is the platform's own locked pass in the management service, every ten minutes on the stale-deploying sweep's cadence, one replica per tick. It runs outside the switch gate, so it meets no posture gate. It starts each expired batch's first purge once, by a compare-and-set of `swept_at` from null in the statement that starts the purge, so a second tick starts nothing. That purge carries `drop_metering: true`, the batch's own requesting account, and a `request_id` of null, never a batch identity. A batch identity would let an operator's earlier purge under the same key answer the sweep's as a repeat and start nothing. The purge also carries an action record whose actor is the requesting account under the credential kind `platform_sweep`, the platform's own act, which holds no grant and no destructive class (MAPI-06; MAPI-12).

A batch whose seeding credential reads revoked or expired is swept at the next tick, so no batch outlives its credential. A batch whose credential is null is swept at its expiry alone.

The pass's catch-all returns what a failed walk left. Each tick, a builder-realm user row carrying the `synthetic` flag is due where it is older than the posture's lifetime by its own creation instant (`compat`'s lifetime under `off`). It is also due where a swept batch whose expiry is past names it. The sweep starts one purge per requesting account for the due rows under a fresh per-tick `request_id`, never a batch identity. The requesting account is the batch's own where a swept batch names the row. Otherwise it is the account opened by the first entry, in the setting's order, of the control plane's operator set `SUPER_ADMIN_IDENTITIES` whose identity has opened one (MAPI-09). So where no entry has, the rows a swept batch names are still purged under the batch's own account, while the rows no batch names are skipped with a marker line once per pass.

A row is excluded while an unswept batch names it or while a purge account row in `pending` or `running` holds it. So a walking account is never walked twice, and one tick's purge is not restarted at the next. A tick that swept a batch or started a catch-all purge writes one info line to the control-plane stream naming the batches it swept, the purges it started, and the count of the catch-all's accounts. A tick that did neither writes none. The console marker line below is apart from that line.

The codes held under an account are its own sign-in's on the builder realm, and those of fixture end users in the realms of applications it owns. ACS-L0-12 holds a code under an account in an application's realm only where the realm's owning account is synthetic and the address is at the fixture domain. So the read answers such a code by the owning account and the start's binding hash, and answers nothing of a person's sign-in. It answers no code for an account whose record is gone, whatever row a start left standing under it until the sweep's delete.

This paragraph states that a test end user's code is held under its realm and user, never under an account or an address, so this read answers none of it (ACS-L0-20).

The management service writes a console-log line carrying a marker constant when a seed is refused at a ceiling, when the standing accounts pass half the posture's ceiling, and when the sweep starts a purge over an account that still stands. Such a purge is every catch-all purge, and a batch's purge where an account the batch names outlived its seeder's own purge. The service writes no line for a batch's purge whose accounts are all gone, which completes with zero removals and is started all the same for the metering it drops. It writes none there because the ordinary batch's seeder purged it long before its expiry, and a line there would mail the operator at every seed's expiry. The line's count is the accounts still standing.

The fifteen refusal names this statement owns are rows of `schemas/wire_errors.json` (MAPI-15). `synthetic_estate_bounded` (403) answers a token the grant bounds on a row outside the bound. `synthetic_seed_purge_bounded` (403) is the same answer for a token the `synthetic_seed_purge` grant bounds, on a row no grant marks. `publication_bounded` (403) is the same answer for a token the `publication` grant bounds, `feedback_queue_bounded` (403) for a token the `feedback_queue` grant bounds, and `issues_bounded` (403) for a token the `issues` grant bounds. `tzmesh_bounded` (403) is the same answer for a token the `tzmesh` grant bounds, and `tztrack_bounded` (403) for a token the `tztrack` grant bounds. `device_sign_in_bounded` (403) is the same answer for the session the device grant bounds (MCP-02). `issues_level_refused` (403) answers a relayed act the level of the token's `issues` grant does not admit, naming the level and the acts it admits.

`synthetic_estate_disabled` (403) answers every wire write of the estate while the posture reads `off`. `synthetic_posture_refuses` (403) answers an act the standing posture does not admit, and a seed past the `synthetic_seed_purge` grant's own bounds. `synthetic_ceiling_reached` (409) answers a count the posture bounds, and the `synthetic_seed_purge` grant's own two ceilings. `account_not_synthetic` (409) covers the code read and the state read beside the purge, the two reads under `super_admin` alone. `account_outside_batches` (409) answers the purge, the code read, and the state read under a synthetic grant naming an account outside the caller's batches. The two reads read the reach first, as the purge does under `synthetic_seed_purge`. Under `synthetic_seed_purge` it also answers a purge repeating another credential's `request_id`.

A test in the platform's suite holds the seed with its batch and its `sign_in` option, the purge with its scoping under the narrow grant and its join, the reads, and the posture with its grammar and its alias. It holds each ceiling at its refusal, the grant, and the bound of each bounding grant at the dispatcher's gate, in the listing, and on the two data planes. It holds the `synthetic_seed_purge` grant's three rows, its bounds on a seed, its two ceilings, and its scoping of the purge, the read, and both repeats. It holds the sweep — its once-per-batch mark, its null `request_id`, its credential rule, and its catch-all — the code read, the usage member, the alert line, and the interruption. It holds an application realm's code read, the purge's delete of held codes, and no code for a gone account.

The default `setup` answer carries no `kind`. Where ACS-L0-23's published welcome file passes, it composes that file's subject and text, with `file` naming it and `source` `site`. Otherwise it uses the plane's built-in text directly, with `file` null and `source` `built_in` (ACS-L0-23). `refused` is null when the welcome file is absent, and gives its check's reason when a present file is refused. The account's sign-up link chooses the product word in the welcome address, never a file. It answers `account`, nullable `sign_up_link` and `file`, `source` as `site` or `built_in`, nullable `refused`, `subject`, `text`, `html` and ordered HTTPS `links`. The common `contract_version`, `reference` and `detail` stand beside them.

A `reminder` or `connected` answer adds that `kind`. The reminder composes the welcome file's text under its `reminder_subject`; it has no usable words where that file is absent, refused or lacks that subject. The connected email reads its one published file. Neither has a fallback or built-in words.

With usable words, `source` is `site`. With none, `source` is `none`, `file` is null, `subject`, `text` and `html` are empty, and `links` is empty. `refused` gives the file's refusal, or null. The welcome address receives the sign-up product as ACS-L0-26 states, in the synthetic read as in a send. The read works on either estate with the posture `off`; links point to production, and each read is recorded.

Under `synthetic_estate`, it reaches the batches the caller's own credential seeded and every first-sign-in batch. An account outside that reach is refused 409 `account_outside_batches`, the reach read first. Under `super_admin`, any synthetic account is admitted and an existing non-synthetic account is refused 409 `account_not_synthetic`. Under `super_admin`, an unknown id is refused 404 `not_found`. The required `account` is the only account selector; `kind` chooses the email. No address or binding is accepted.

A first sign-in at the fixture domain (ACB-L0-79) writes one batch at its confirmation. Its requesting account is the operator set's first opened account (MAPI-09), its `seeding_credential` null, and its `request_id` `first-sign-in:<lowercased address>:<account id>`. Its expiry is the posture's lifetime from the creation instant, so the lifetime sweep takes an abandoned account by its batch as it takes any expired batch, and the catch-all reads nothing new. A confirmation whose batch write fails removes the account it created, so no account stands at the fixture domain that no batch names. A label re-used after its first account's purge writes a second batch, the first untouched.

The prefix `first-sign-in:` is reserved to that write: a seed carrying a `request_id` opening with it is refused 400 `invalid_request`, and no seed answers such a batch as a repeat. The form is one exported constant of the estate module, read by the store and by the confirmation.

Its reach is the code read's, the hosted trial's token refused `grant_required`. Under `synthetic_estate` any account outside the caller's reach refuses 409 `account_outside_batches`, a standing customer account and an id no account stands for among them, the reach read ahead of the not-synthetic check. Under `super_admin` a standing account that is not synthetic refuses 409 `account_not_synthetic` and an id no account stands for 404 `not_found`.

MAPI-17: The operator signal is one grant-marked row of the enumeration, by which a company test harness reports a run's ending, or its result, to the operator under a source name. The row is `resource` `account`, reversible tier, marked `grant: synthetic_estate` (MAPI-09). So the dispatcher's grant gate admits a credential holding `synthetic_estate` or `super_admin` and refuses every other credential `grant_required`, a customer's session among them, save where a refusal that answers a credential ahead of the grant gate answers it first (MAPI-14). A token the `synthetic_estate` grant bounds is admitted to it as it is to the synthetic estate's six rows (MAPI-16). The row is no row of the synthetic estate, which stays the six rows MAPI-16 names: the act touches no test fixture and names no account.

It carries no `switch` mark, so it is listed and answers whatever the `SYNTHETIC_ESTATE` posture reads. It carries no `request_id`, each call being one report, and no `clients` member. Its annotations are `readOnlyHint` false, `destructiveHint` false, and `openWorldHint` false, with no `idempotentHint` member, each call writing another counted line (MCP-11). The request names `event`, `source`, and an optional `detail`. `event` is one word of a closed vocabulary of two: `ok`, a run that ended clean, and `failed`, a run that did not end clean or a result that failed. The words are generic, and the name of what is reported is carried in `source`, which matches `^[a-z0-9_.-]{1,64}$`.

`detail` is a string of at most 200 characters, a null refused as any other non-string, counted on the wire in code points as a JSON Schema `maxLength` counts them. The MCP tool's derived validator counts UTF-16 units and so refuses, ahead of the platform, a detail of characters outside the Basic Multilingual Plane that the wire admits. `detail` is scrubbed before it is written: the value of a minted token, of an end user's session, and of a transfer grant, an address, and a URL are each replaced by a marker.

A `source` or a `detail` that contains `control_plane_`, in any letter case, is refused. It is refused because that prefix begins every marker the platform's own log lines carry and the platform's marker rules match a marker over a whole line (PLD-L0-67), so a free member naming a marker would satisfy another rule. A `source` that contains the prefix of one of those three credential values is refused too, a `source` being written to the line as given. A request outside these shapes answers 400 `invalid_request` with the member named in the detail, and the action adds no refusal name (MAPI-15).

This paragraph qualifies "three credential values" in the scrub and in the refused `source` with the egress key (SEC-L0-18). A value of its shape in `detail` is replaced by a marker as the other three are, and a `source` that contains its prefix, `turnzero_cloud_egk_`, is refused.

The act writes one line to the management service's standard output, a JSON object of exactly the members `marker`, `event`, `source`, `detail`, and `credential` in that order. `marker` is the constant `control_plane_operator_signal`, and `detail` is the scrubbed text or null. `credential` is the calling credential's identity, the value the action record names (MAPI-06), a minted token's id and null for a session, which carries none, so a line a token wrote is attributable from the log store alone. The act writes nothing of its own beyond the line, no table, no setting, and no fixture, and the dispatcher records and meters the call as it does every action's (MAPI-06). The answer is `recorded: true` with the event and the source as given.

The plane's workflow starter Job (PLD-L0-67) is the line's second writer. For each failed run its GitHub App dispatched, it writes to its own console log a `failed` line of the same members in the same order. Its `source` and `detail` are held to this statement's bounds and scrub, and its `credential` is the fixed word `workflow-starter`, since no credential calls the act there.

The tier is reversible and not observe because the line can notify the operator. PLD-L0-67 owns the two alert rules that read it, the failure rule that counts `failed` lines split by a bounded source and the heartbeat rule that reads the newest `ok` line of one named source. This statement owns the row, the vocabulary, the bounds, the scrub, and the line. The action has no rate bound and no refusal name of its own: a harness makes a few calls a run. For any other holder of the grant, the platform's admission window per source address (PLD-L0-67), inside the edge's own limit on the management path, bounds the lines one address can write.

Every holder of the grant is admitted to the row, so a disclosed copy of any token carrying it can write a line under any source name. Among those lines are a `failed` line that notifies the operator and an `ok` line under the source the heartbeat rule reads, which keeps that rule from firing. The line names its credential, and the credential register's rows state that reach (CRD-14; CRD-17).

The event words and the wire call have one home beside the platform's other operator clients. A client script exports the two words and makes the one call, and it loads the operator client inside the call alone, so that importing the words runs nothing. The platform's suite holds the script's words, the platform module's words, and the payload schema's `enum` equal. It also holds the request as the client sends it, the client's refusals ahead of a call, and a refusal's status and code passed on as the wire call threw them.

MAPI-18: The four feedback actions, `submit_feedback`, `read_feedback`, `settle_feedback`, and the staff row that posts a check, are rows of the enumeration on the `account` resource (API-L0-20; the AI tool interface's feedback scenario). Beside them stand the destructive row `redact_issue_text` (ITS-L0-05) and the relay `relay_issue_act`. The four space rows are `create_space`, `list_issue_spaces`, `delete_space` and `rename_space`, whose forms the issue service PRD's relay and provisioning rows state. This statement states their bounds and refusals, except those of `delete_space` and `redact_issue_text`, which the issue service PRD states (ITS-L0-01; ITS-L0-05). Each is registered while the control plane's setting `ISSUE_SERVICE_ORIGIN` names the issue service, and unlisted, refusing `not_yet_provisioned`, while it is empty (MCP-08; MAPI-10).

On every call to the platform's own space the plane presents the space's first token, which the setting `ISSUE_SERVICE_TOKEN` carries by secret reference (CRD-19), on the package's 0.3.0 wire, the recovered mark alone on the 0.2.0 wire. On a call naming `space` it presents that space's own token, read from the plane's vault or, for a standing pair's space, from custody, and on the relay the named space's own token. On a provisioning act and on an account space's creation it presents the provisioning credential the register's issue service provisioning credential row states. The platform space's owning account is the setting `ISSUE_SERVICE_PLATFORM_ACCOUNT`, empty where unset (the issue service PRD's relay row).

Each of the three feedback rows takes `space` beside its own members (the issue service PRD's actions row); the check row takes none. `space` names, as a lower-case UUID, a space the acting account holds, which the call then addresses under that space's own token: a space of the account's own, an application's own space, or one space of a standing pair. An identifier matching none refuses 404 `not_found` before any token is read; a token that does not answer refuses 503 `issue_service_unreachable`. A request naming `application` or `environment` refuses `invalid_request` naming `space`. The bounds below are judged before the space is resolved.

With `space`, `read_feedback` addresses that space under its own token in every form and `settle_feedback` settles an issue of it, no grant read. The scope gate refuses a token bounded to an application on the three rows `token_scope_refused`, the form naming no application (API-L0-17). The removal of `application` and `environment` from the four rows is MAPI-02's thirty-eighth use of its within-version allowance, made while the platform held one builder account and six live applications, a synthetic account aside. The paragraphs below state each row on the platform's own space.

`submit_feedback` is reversible tier, unmarked, carrying `admits: ["synthetic_estate", "tzmesh", "tztrack", "device_sign_in"]` (MAPI-16), so any bearer, any account-scoped minted token, a token the synthetic-estate, `tzmesh`, or `tztrack` grant bounds, and a session the `device_sign_in` grant bounds file into the platform's own space. The request names `source`, the actor's kind, `person`, `agent`, or `system`, with `provider` and `session` on an agent's, both or neither. It names `kind`, one of the record's eight, `bug`, `gap`, `docs`, `friction`, `question`, `task`, `praise`, and `idea`, or a word read as one of them. Those words are `missing_capability`, `documentation_gap`, `refusal_not_understood`, `problem`, `error`, and `mistake`, which the record accepts, and the 0.2.0 word `usability`, which the plane files as `friction` (the package's XIT-01; XIT-04). It names `title`, 1 to 200 characters. A `question` or a `task` is refused `invalid_request` from a filing the plane gives the `field` origin, ahead of any call.

Its optional members are `text` (or `body`), of at most 20,000 characters, `impact` (or `severity`, read as an impact), and `workaround` and `proposed_resolution`, each of at most 4,000 characters. They are also `labels`, `evidence`, `restricted`, `problem_key` (or `key`), and `repeat_of`; two names of one member are refused together. `product` names the Turn Zero product a report concerns, by its technical name, is refused `invalid_request` otherwise, and is written as the label `product:<name>`. `evidence` holds `action`, `refusal`, `reference`, and `code_site`, each 1 to 200 printable characters, the 0.2.0 `environment` and `version`, which the plane reads as one build the report saw, and a `context` of at most 20 short named strings.

The request declares neither `personal` nor `excerpt`, and a call that names either is refused as MAPI-22 states. The `report` the answer carries holds no `personal` member.

`files` attaches 1 to 4 images to a filing, and to no confirmation, amendment, or recovered mark. Each item names a file `mint_upload_grant`'s put line stored: `application`, an application of the acting account; `area`, an area bound to it; `name`; and `environment`, the application's deploy target where absent. The plane reads each file under the call's own credential, by the reach the storage route reads (OST-L0-03), through the store's streamed read.

A file it does not find, one in the platform-held deploy area, and one the credential does not reach are refused 404 `not_found`. A file past the package's `attachmentBytesMax` is refused `invalid_request` by its stored size, before its bytes are read. Each refusal names the file's place in the list and comes before any call, so nothing is filed. The plane relays the bytes as the filing's `attachments`, the service judging their type (the package's XIT-05). No record row, log line, or refusal carries them, and the plane serves no image on its own origin.

The plane gives each report its origin and no filer names one (the package's XIT-04). On the platform's space a `system` filing under a credential holding the `synthetic_estate` grant is `beta`, the AI beta run's, and every other filing `field`; on a space the request names a person's filing is `person`, an agent's `workspace`, and a program's `test`. On a space the request names, a confirmation is relayed as given under that space's own token, and the service then judges it, and a filing's link by evidence, by the report's origin (the package's XIT-05).

On the platform's space a filing whose `labels` names `synthetic`, the mark of the platform's own test runs, is admitted from an account whose record is marked synthetic alone (ACB-L0-79), an access-link account excepted, since one person holds it (ACB-L0-87). Every other filer of this action is refused `invalid_request` naming the label, ahead of the bound and any call, a credential's grant deciding nothing.

A `submit` relayed through `relay_issue_act` under the space's `issues` grant is a trusted session's and is not held. The triage pass reads no issue carrying the label there (the package's XIT-07), so a customer's report cannot leave triage by naming it. The plane names the label on no filing of its own accord, and on a space the request names it is a label like any other. This statement records a use of MAPI-02's shape clause on `submit_feedback`'s `labels`. The platform then held four builder accounts that each held a live application, synthetic accounts excluded, read at the change.

The plane writes the actor kind `person`, on every form of `submit_feedback` and on the check row, only under a credential a person holds, a builder session (ITS-L0-05). Under any other credential, a minted token among them, a `source` of `person` is written as `agent`, and a filing's origin follows the kind written: `workspace` on a space the request's `space` member gives, and `field` on the platform's space. A `source` of `agent` or `system` is written as given.

`problem_key` names the problem among the caller's own reports. A same-key repeat whose evidence and words equal the earlier report's answers `retried`, and one whose evidence or words differ files a second report linked to the same issue, `linked`. A `praise` filing and a filing of another kind under one key are apart: neither is a retry or a repeat of the other, and each is answered an issue of its own side (the package's XIT-05). With `key`, `recovered: true`, and no member of a filing, the call is the 0.2.0 recovered mark, relayed on the 0.2.0 wire, which settles the open filing the key names among the caller's own as recovered. The service settles it only where the caller's own filing under that key opened the issue and every report on it is the caller's; otherwise it refuses the mark, and the call answers 404 `not_found` (the package's XIT-01).

With `amends`, the number of one of the caller's own reports and never an issue's, the call is an amendment, the filer's correction or withdrawal of that report (the package's XIT-05). Beside `source`, `space`, and the session's members it takes `withdraws`, true or false, `title`, `text` (or `body`), `impact` (or `severity`), `workaround`, and `proposed_resolution`. Each of those it leaves out carries from the latest amendment of the amended report that withdraws nothing, or from the amended report where none stands. A null `text`, `workaround`, or `proposed_resolution` clears that member, as an empty `text` clears the text (the package's XIT-05). A filing refuses null on `workaround` and `proposed_resolution`, and reads a null `text` as no text.

An amendment also accepts `kind`, `labels`, and `product` under the filing's rules. A praise report can name only `praise`. Other reports can name any allowed kind except `praise` (system:XIT-05). If an amendment names `labels` or `product`, give the full set of filing labels. `product` adds `product:<name>` to any labels supplied. The service replaces the filing labels only on the issue the amended report opened and only while no space member has set them by hand (system:XIT-05). At least one amendment member must be present. Every other member refuses `invalid_request`.

The plane relays it as one `submit` naming the actor and the origin a filing names, counted once in the bound, and makes no read of its own. It names no `evidence_basis`, since the stamp reads `evidence`, which an amendment does not carry: the evidence stays on the amended report, which no amendment edits.

The service admits a report the acting account filed and no other, so another account's report is answered 404 `not_found`, as a number no report carries is, and nothing is filed. The answer is a filing's: the amendment's report, carrying `amends` and `withdraws`; the issue through the projection, or a null `issue` where it is withheld as a filing's is; the outcome `amended`; no candidates; `masked`; `personal_removed`; and `stamped` false.

The answer carries the caller's own report, the issue through the projection without `reports`, the outcome, `filed`, `linked`, `retried`, `noted`, `confirmed`, `related`, or `amended`, up to three `candidates` it may repeat, `masked`, the credential forms the service's scanner hid, and `stamped`. It carries `personal_removed` too, the personal forms the scanner removed from the filing in the order it applies them, as the service answers it, and empty where none was removed (the package's XIT-05).

On the platform's own space, `submit_feedback`'s and `read_feedback`'s answers carry the projection with `requirements` null, since it holds the statement identifiers of an issue closed as designed (MCP-05). They also carry `note_to_reporters` null where the note carries a statement or decision identifier, read by its form as the MCP-05 census reads one, so a token of that form in a plain note withholds it too. A filer there reads the close's fixed sentence and a note's plain reason, and no statement behind either. A landing's note, in its one fixed form, carries none and is answered as the package's XIT-08 gives it. A team's own space and the check row's answer carry both members whole (the package's XIT-08).

The plane answers each candidate as the service answers it, except as the next paragraph states. Its title is the issue's or null by the package's rule, so a candidate carries no title that a report of an origin other than `workspace` or `platform` gave (the package's XIT-05). `repeat_of` beside a filing confirms a candidate after the filing, and `report` with `repeat_of` and no member of a filing confirms one alone, the contract's `follow` (the package's XIT-05); a filing that confirms counts two calls in the bound.

On the platform's own space, a credential that does not read the queue is answered no candidates: a reporter sees its own reports alone, and the platform team links a duplicate at triage. Such a credential may still name in `repeat_of` an issue that holds one of its own reports, judged as the next paragraph states.

On the platform's own space, for a credential that does not read the queue, the plane reads the issue a confirmation names before it relays the `follow`, the read counted once in the read bound. The read names the caller's account as the reading actor, so the service answers its projection, an issue a merge closed as a duplicate answered as its master (the package's XIT-08). The `follow` then names the issue the read answered, and so do the answer's `repeat_of` and issue. A confirmation that names a restricted issue, or an issue holding no report of the caller's account, is answered 404 `not_found` exactly as one that names no issue is, and links nothing. So is one whose master is restricted or holds no report of the caller's account, the merge chain, its bound, and a duplicate naming no master being the service's projection's to decide.

A credential holding `feedback_queue` or `super_admin`, which reads the queue, has its confirmation relayed as given, with no read. The service then judges it: it confirms a report of the origin `field` or `beta` onto no restricted issue under any token, and refuses the `follow` as one naming no issue (the package's XIT-05). So that credential is answered 404 `not_found` too, and nothing is linked. The plane's reading stands as a second check: it judges the record's own `restricted` member, and answers a record that carries none as a restricted one.

On that space, a filing whose answered issue is restricted, or carries no `restricted` member, answers a credential that does not read the queue its own report, the outcome as given, and a null `issue`, no member naming the issue, whatever linked the report. A `repeat_of` naming that issue is answered as one naming no issue is. The report stays filed.

The service itself links a report of the origin `field` or `beta` to no restricted issue by its evidence, so such a filing is answered the unrestricted issue it joined. One whose evidence matched a restricted issue and nothing else opens its own issue restricted, and answers that credential the null `issue` (the package's XIT-05). A filing that asks the mark itself, and a repeat under the filer's own key onto a restricted issue, answer that credential the null `issue`. The plane's withholding stands as a second check, judged from the record's own mark.

A confirmation across the `praise` kind links nothing: the service answers `related` with the report's own issue, and relates the two issues as the package states (XIT-05). The plane answers that word and that issue through the projection, or a null `issue` where it withholds the issue as a filing's answer is withheld, and no member names the relation. A filing beside `repeat_of` whose confirmation is answered `related` keeps its own issue, carries no `repeat_of` member, and reads `outcome` `related`. On a space the request names, the owner is answered the same word and the issue through the projection.

On the platform's space, for a credential that does not read the queue, the plane relays the recovered mark only where the filer's filing under that key opened the issue it lands on, and that issue is unrestricted and holds that filer's reports alone. Otherwise the plane refuses it 404 `not_found` before any write. A key under which the filer holds no report is refused by the plane as the service refuses it, relaying nothing, and a read the service could not answer is refused as any unanswered call is. A relayed mark answers the issue's `id`, `status`, and `disposition` alone, and the plane's two reads ahead of the mark count in the read bound.

Where the evidence quotes a reference, the plane reads the newest row of the action record carrying it under the acting account within the twenty-five days before the filing, once more after the record's one-second flush where the first read finds none (MAPI-06). Under a credential holding the `synthetic_estate` grant it reads the accounts of the batches that credential seeded too, the synthetic-batch clause (MAPI-16).

Where a row joins, the evidence carries the row's `action` and the context the filer gave. Where the row's outcome is a refusal, the evidence carries that `refusal` and the row's `code_site` too and is stamped on either of two grounds. The filing's kind, an alias read as its record kind, is `bug`; or its impact is `blocked`, its kind is neither `praise` nor `idea`, and the action is one of the target space's `critical_actions`. The latter ground reads the target space's configuration once; a failed read admits no critical action, so only a `bug` stamps.

The stamped request goes to the service with `evidence_basis: stamped`. Where the call completed or waits for approval, the request keeps the filer's refusal, if any, as claimed evidence, with no basis and no code site. A filing citing a refused call that meets neither ground names the refusal alone and stands `claimed`. The action record names no refusal for an answered call. At filing, the service neither fingerprints nor joins a claimed report by a refusal with no code site. A stamped report joins by its action, refusal, and component, subject to the package's rule keeping praise apart from every other kind (the package's XIT-05).

The `seen_in` of a report whose row joins names the build that answered the call: its version the build's source commit, and its environment the plane's, `development` where the estate's apex opens `dev.` and `production` otherwise. Its `release_line` is `cloud.plane` where the platform's space declares that line and null otherwise (the package's XIT-14). Where no row joins, the filer's evidence stands `claimed` for the daily pass's join (PLD-L0-67). The filer's 0.2.0 `environment` and `version` name the one build the report saw.

The daily pass confirms a report only where both its own kind and the kind of the issue it stands on pass the test below.

- the kind is `bug`; or
- the report's impact is `blocked`, the kind is neither `praise` nor `idea`, and the call action is one of the platform space's `critical_actions`.

An old report with no kind uses the issue's kind. The pass reads the platform space's `critical_actions` once a run; a failed read admits no critical action, so both kinds must be `bug` to confirm.

`read_feedback` is observe tier, unmarked. With no member it answers the caller's own submissions through the projection, the caller named as the reading actor (the package's XIT-08), paged by `limit`, 1 to 100 and 50 where absent, and `cursor`, selected by `state`. The 0.2.0 `status` reads as a state and `unreviewed` as `new`. With `issue`, a short identifier, it answers one of the caller's own through the projection, another account's and an unknown id both answered `not_found`. The detail names the caller's own submission for the number only where the service answers `own`, an issue the caller reads (the package's XIT-08). Another account's issue, a restricted one, and an absent number name none and read alike. With `query`, 1 to 200 printable characters, it searches the caller's own submissions, selected by `state`, `kind`, and `component`.

On the caller's own, queue, and named-space lists and searches, `reporter_accounts` takes 1 to 20 account identifiers of 1 to 200 printable characters and selects each issue once when an eligible report's recorded account matches one of them. Only reports in the call's existing read scope can match. In the caller's own forms, these are the caller's projected reports. A call naming `reporter_accounts` beside `issue` is refused `invalid_request`.

The own list, search, queue, and named-space lists answer compact entries in `issues` by default. An entry of a whole issue selects `id`, `kind`, `title`, `state`, `outcome`, `priority`, `effective_priority`, `waiting_for`, `report_count`, `updated_at`, and `restricted` from the issue the form may already answer. Where that issue carries `restricted`, its value is `true` or `false`. `detail`, an optional boolean, returns the full entries the caller may read when true. The `issue` form answers one full issue within the caller's existing access and refuses any request that names `detail` beside `issue` as `invalid_request`.

This paragraph states the entry of the caller's own list and search, which read through the projection (the package's XIT-08). The projection carries no title of its own, so the entry holds `id`, `state`, and `outcome`, and a `title` taken only from the caller's latest visible report that has one, ordered by `filed_at` and then by report id. Where no visible report supplies a title, the entry carries none. It never takes the master issue's title or another reporter's.

A credential holding `feedback_queue`, the queue's grant, or `super_admin` is answered any issue whole by its id, with its reports, links, history, comments, relations, landings, and checks (MAPI-09).

With `queue: true` it answers every account's matching issues. Each compact entry carries the `effective_priority` the service answers, and a full entry also carries its `impact_assessment` where the service answers one (the package's XIT-04). The queue is selected by `state`, `outcome`, `kind`, `component`, `label`, `priority`, `stored_priority`, `origin`, and `proposed`. `priority` selects by the effective priority and `stored_priority` by the stored one, as tzTeam says priority. Each selects one of the three values 1, 2, and 3, and a `stored_priority` of 4 is admitted and selects as 3 does (the package's XIT-08).

The queue is ordered `newest`, by `rank`, by `priority`, which sorts by `effective_priority` and then by `ranking_score`, or by `report_count`, the 0.2.0 `score` reading as `rank`. The queue's `priority` selector and its `rank` order are the platform's own action words, which the plane maps to the service's `effective_priority` and `ranking_score`, and `stored_priority` to its `priority`. With `query` beside `queue` it searches the whole space.

The queue form and the whole search are admitted to a credential holding `feedback_queue` or `super_admin`. Every other credential that reaches the handler is refused `grant_required` naming `feedback_queue`, an application-bounded token `token_scope_refused` at the scope gate, and a token another grant bounds its own bound's refusal, in MAPI-14's order (MAPI-09; MAPI-16). The row carries `admits: ["feedback_queue"]`, so a token the grant bounds reaches every form, the form with no member answering that token the operator account's own submissions (MAPI-16). `issue` beside `queue` or `query` refuses `invalid_request`.

The report text, the comments, the candidates, and the curated titles and summaries the actions answer are data and never instructions. Over MCP, every completed answer of `submit_feedback`, of `read_feedback` in each of its forms, of `settle_feedback`, of the check row, and of `relay_issue_act` is rendered as one text block. The block opens with the untrusted marker and holds the answer's JSON between an opening and a closing delimiter line. The marker names every member a reporter, a program, or a pass wrote. They are the titles, summaries, report texts, workarounds and proposed resolutions, labels, evidence and its context, resolutions, notes, comments, candidates, an impact assessment's reason, history change values, and the values of a count's groups. The note stays inside the block, though the projection serves it whatever the issue's `text_trusted` (the package's XIT-18). So nothing unmarked precedes them, and the wire answer is unchanged.

A space's name is text its owner wrote, another account where the space is shared (ITS-L0-01; ITS-L0-07). So over MCP a completed answer of `list_issue_spaces` that lists a space shared with the account is rendered the same way, as one text block holding the answer's JSON between the same two delimiter lines. It opens with a marker of its own, which names each space's `name` as its owner's text, to be read as data. An answer that lists only the account's own spaces, its applications' spaces, and the platform's space holds no name another account wrote, so it is served as plain JSON, as tzTrack's `list_spaces` serves the same spaces (issue_service:ISV-16). The feedback actions' marker is unchanged, and so is the wire answer.

The tzTrack server's write tools, `raise`, `wait`, `update`, `comment`, `close`, `reopen`, `claim`, and `give_back`, render a completed answer compact where it carries no text member anyone wrote (tztrack:TRK-L0-03). The compact answer holds the relay's envelope, the outcome, the report's and the comment's numbers, and of the issue its `id`, `kind`, `state`, `outcome`, `priority`, `due_date`, `restricted`, and `waiting_for`. It keeps the scanner's form names, `masked` and `personal_removed`, the issue ids an update or a comment mentioned, and a settle's `related_open` rows. Every other member is left out, the caller's own text and `claimed_by`, a free label, included. It is rendered as its JSON alone, with no marker and no delimiter line.

`waiting_for` is kept in its closed forms alone: null, `person`, `reporter`, `evidence`, or `person:<account>`. A `raise` that joined an issue or whose answer lists a candidate, an answer whose issue's `waiting_for` holds any other value, `outside:<what>` among them, and every read tool keep the whole answer inside the block, since another party's text may be in it. The wire answer of the relay is unchanged.

`settle_feedback` is reversible tier, unmarked, carrying `admits: ["feedback_queue"]`, the queue's own grant, decided at the handler. On the platform's own space the act is admitted to a credential holding `feedback_queue` or `super_admin` and refused every other credential `grant_required` naming `feedback_queue`; with `space` it settles an issue of a space the acting account holds with no grant read (ITS-L0-03). A token holding the grant and not `super_admin` is bounded by it as MAPI-16 states: refused `feedback_queue_bounded` on every other row no earlier gate answers, a row another grant marks keeping `grant_required` (MAPI-14; MAPI-16). It is minted on MAPI-14's terms from a session holding `super_admin`. So a session that triages the queue from an AI client holds no credential a planted instruction could turn to a filing or to any act beyond the queue.

The act names `issue` and `act`, one of `settle`, `merge`, `wait`, `reopen`, `unmerge`, and `triage`, with an optional `key`. `settle` names an `outcome`, one of the record's eight, and, where the outcome is `duplicate`, `target`, the master. A `resolution` of 1 to 4,000 characters is required for every outcome but `noted` and `duplicate`, and the 0.2.0 `disposition` reads as its outcome (the package's XIT-01). `merge` names its `target` and closes the issue `duplicate`; `wait` names its `resolution`; `reopen` and `unmerge` take neither. `approve` and `decline` are retired and refused `invalid_request` by name: no person approves or declines a duplicate, which the service's passes merge where they agree on stamped or confirmed evidence (the package's XIT-07). An act the issue's state excludes refuses `invalid_request` naming the service's refusal, and the answer carries the issue as it now stands.

`triage` names `kind`, one of the record's eight, or `component`, a component the space admits (the package's XIT-14), or both, and the plane relays the package's `update` setting them (the package's XIT-06). On a `new` issue that update opens it, so a fix can then be settled `done` (the package's XIT-16). `triage` takes no `outcome`, `disposition`, `target`, `resolution`, or `fixed_in`.

With the outcome `done`, `settle` may name `fixed_in`, the build that serves a fix closed by hand, `{ release_line, version, environment }` or null, and the plane passes it to the service as given (the package's XIT-07). The service requires it on a `bug` or a `friction` holding a report of a returning origin where no landing stands. Its absence there is refused 400 `invalid_request` naming the service's refusal, as any refusal of the act is, and a `fixed_in` that names no build is refused 404 `not_found`, as the service's not-found refusals are.

A `merge`, and a `settle` with the outcome `duplicate`, where exactly one of the issue and its `target` is of the kind `praise`, are refused 400 `invalid_request` naming the service's refusal `relation_refused` (the package's XIT-07). The service judges the kind before the issue's state, so a `praise` issue closed `noted` is refused the same.

The plane posts the check into the platform's own space naming the acting actor, so the service judges the key among that actor's checks, and answers `{ check, issue, outcome }` (the package's XIT-17). The filing bound counts the call.

A refusal the dispatcher answers, and an internal failure, carries after its `detail` the known-issue line where the plane's copy of the known-issue table names the action and the refusal (PLD-L0-67). The line names the issue's identifier and its trusted workaround where one stands, and, once a fix has shipped, the build that carries it and an invitation to report the refusal again naming `repeat_of` where it is still seen. The line is read from the process's copy, loaded at boot and every minute, never from the store or the service at the call. The dispatcher also writes on every action record row the build that answered the call and, on a refusal the handler threw, the code site, `<file>:<line>` (MAPI-06).

The plane bounds the calls it relays in fixed windows of one minute. Each count is taken before the call as the service counts its own, a refused call counted with the rest, and each past its figure is refused 429 `feedback_rate_limited` with a cause word of its own. The filings and checks are at most 20 from one account and at most 100 from every account together. The reads of `read_feedback` are counted once per service call the form makes, one for each form. They are at most 20 from one account and at most 50 from every account together.

Each relayed call counts once in the window of the credential that made it, at most 60 a minute for one token by its identity, a session's account where it has none (MAPI-06). It counts once more in its target space's aggregate, at most 150 a minute for an account's own space. A relayed call counts once more there for each call the platform may make beside it (ITS-L0-05). The platform's own space counts its relayed calls in the two aggregates above, a read act among the reads and every other act among the filings. An account creates at most 5 spaces a minute through `create_space`, and renames at most 5 a minute through `rename_space`, in a window of its own. The relay's figures and the overshoot stay at or under two-thirds of a space's own rate, so a space's other callers keep their third.

An account holds at most the `subscription-issue-spaces` cell of its plan as ACB-L0-92 reads it, during the introductory period as well as after it, an `unbilled` account reading Tools Plus (PRC-L0-19; ACB-L0-90). At its limit, a creation naming a space it does not hold is refused 403 `space_creation_ceiling` with nothing created, and a repeat naming a space it holds answers `created: false`.

The refusal's detail names the plan, count and limit, and points to a space the account already holds or to `delete_space`, which a person approves in the browser. While `tztrack_billing` reads 0 (PLD-L0-76), it names no plan choice. After the end act, it also names a move to a larger plan where one exists. An account holding more than its limit keeps every space (ACB-L0-90).

The `name` of `create_space` is required on every call, a repeat among them, and is 1 to 100 printable characters. One absent, outside that, or no string is refused 400 `invalid_request` naming `name` as the request's form is judged, with nothing created and nothing counted. Over MCP a call without it draws the argument's validation error naming `name` before the handler. The name is written only where the creation puts the space's custody entry, so a repeat finding the entry standing writes none and answers the name that stands (ITS-L0-01).

This statement records a use of MAPI-02's shape clause on `create_space`'s request member `name`, optional becoming required on every call. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, and `schemas/mcp_surface.json` move with it. The platform then held 4 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

The gate is read ahead of the minute's bound and this ceiling. A creation by an account lacking the `tztrack` profile, a repeat naming a space it holds among them, is refused 403 `blueprint_required` and does not count toward the minute's 5 (ACB-L0-89).

`rename_space` takes `space` and `name`, each required. The name is 1 to 100 printable characters, as the creation's is. A missing name, one outside that, or no string is refused 400 `invalid_request` naming `name`, and a malformed `space` the same naming `space`, each with nothing written and nothing counted. Past the minute's 5 a rename is refused 429 `feedback_rate_limited` with nothing written. The bound is read after the form and ahead of the space's resolution, whose refusals, `space_not_owned` and `invalid_request`, ITS-L0-01 states. An account lacking the `tztrack` profile is refused 403 `blueprint_required` ahead of the form (ACB-L0-89).

The figures are constants the code holds. They are sized so that the relayed total, the read aggregate, and the replica overshoot together stay at or under two-thirds of the service's space rate of 300 calls a minute, one count across the permission levels (the package's XIT-12). The other third is headroom for the platform's own calls: the erasure, the export's pages, and the daily pass. The export does not count against the relayed cap. Its page reads pace themselves within that headroom and share one bound that ends every read and wait.

The overshoot is what the management replicas together can admit past a figure before a flushed row shows every replica's hits, each replica reading a window as its last flushed row plus its own unflushed hits and flushing every second. It is at most the plane's replica ceiling of nine times five calls a replica in one interval, a design figure the suite holds beside the sum and the template's replica count. The service's own rate refusal answers under the same name.

A call the service could not answer answers 503 `issue_service_unreachable` with the cause word in the detail. The causes are the transport failing, the call passing the plane's bound of ten seconds, a fault of the service's own, the router's quota refusal on it, and a refusal of the platform's own credential. A refusal of the platform's credential is also written once per interval to the control plane's record as a warn line naming the cause, so a lost, revoked, or unset token is read there rather than found at a customer's deletion (CRD-19). The service's not-found refusals answer 404 `not_found`, and every other refusal of the service, a lease's among them, answers `invalid_request` with its name in the detail.

On the relay a refusal of the service by the act's content, the issue's state, a lease, or a record that does not stand answers `issue_refused` with the service's own status and its name in `refusal`. The four refusal names this statement owns, `feedback_rate_limited`, `issue_service_unreachable`, `space_creation_ceiling`, and `issue_refused`, are rows of `schemas/wire_errors.json` (MAPI-15), the last carrying the service's status and a `refusal` member and the rest no member beyond the base six.

The same suite holds a space's name stored and answered, refused out of its bound, kept by a repeat and written by a retry after a lost answer, answered on a member's row, and the listing rendered under its own marker.

This statement records a use of MAPI-02's shape clause on `submit_feedback`'s `issue` on the platform's space. A filing of the origin `field` or `beta` whose evidence matched a restricted issue and nothing else, once answered the unrestricted issue it opened, is answered the null `issue`, because the issue it opens is restricted (the package's XIT-05). The platform held 1 builder account that held a live application, synthetic accounts excluded, read at the change.

Under the usage model (PRC-L0-04), an account holds its own spaces up to the bound `subscription-issue-spaces` states for the usage form, whatever plan it chose or holds. At that limit, `create_space` naming a space it does not hold refuses 403 `space_creation_ceiling`, with nothing created; a repeat naming one it holds still answers `created` `false`. The detail names the count and limit, and no plan. It directs the caller to a space the account already holds, or to `delete_space`, which a person approves in the browser.

MAPI-21: The application-grain data archive is two rows of the enumeration on the `application` resource (API-L0-23). The fifth paragraph states `request_export` with `download: true`. `request_export` is reversible tier and takes `application`, required, and `environment`, optional. It answers 202 on `deploy`'s shape (MAPI-04) with the export's identifier, the state `running`, the export area's name, the export's folder, `repeated`, and `next`, the `read_export` call naming the application and the export (MAPI-24). `repeated` is true where the request answered an export already running for the application and environment.

`read_export` is observe tier and takes `application`, required, and `export` and `environment`, optional. With `export`, it reads that export and ignores `environment`. Without it, it reads the newest export of the application and environment, production where none is named, whether running or ended. The request instant orders exports, with the id breaking a tie. If none is held, it refuses 404 `not_found`. It answers the state, `running`, `completed`, or `failed`, the outcome of a failed export, the progress counts, and the instants. Once the export has ended it answers the manifest, and null where the manifest file is gone.

The outcomes are `interrupted`, `table_bound_exceeded`, `database_failed`, `files_failed`, `area_unavailable`, and `runner_failed`. A token bounded to one application reaches the two rows for that application (API-L0-17). An application id no account holds refuses 404 `no_such_application`, and one another account holds refuses 403 `application_other_account` (MAPI-14). An export the named application does not hold refuses 404 `not_found`. A missing member, or an environment outside the platform's two, refuses 400 `invalid_request`.

The export's row is the act's operational record: its state, its counts, and its instants, and no table or file name. The names are the manifest's, a file of the export area, which ends with the area. A running row whose heartbeat is older than the deploy's stale bound is ended `failed interrupted` by the read that meets it, `read_export`'s or `request_export`'s, and no timer sweeps the rows. A pass whose application is deleted stops at its next heartbeat and ends `interrupted`, writing nothing more into the export area the teardown removed. A test in the platform's suite holds the pass over an engine and the storage double, and the two rows over the routes.

Before its pass writes, `request_export` removes the folders of the pair's earlier ended exports from the export area, so one folder stands per application and environment (API-L0-23). The replaced export's row stands, and its `read_export` answers the manifest null. The suite's test holds the removal over the storage double.

`request_export` with `download: true` is reversible tier and takes `application` and `export`, required, and `local_path`, optional. It answers the export, the application, the environment, `expires_at`, and one line as `command`, `command_windows`, `command_npx`, and `command_npx_windows` (PLD-L0-94). The grant appears inside the four line members and in no other. The row is admitted to the credentials `read_export` admits for the application (OST-L0-08). `local_path` is held to the class `deploy_command`'s `local_path` admits, and a path outside it refuses 400 `invalid_request` (PLD-L0-86). An export that is not completed refuses 409 `export_not_completed`, and a completed one whose manifest file is gone refuses 404 `not_found`. Each refusal mints nothing. A test in the platform's suite holds the mint, its refusals, and the line run against the suite's own plane.

MAPI-20: `restart_application` is one row of the enumeration on the `environment` resource at the reversible tier (API-L0-22). Its request carries `application` and `environment`, the environment one of the platform's two (PLD-L0-40). Its answer, status 202, carries the contract version, the application, the environment, the version the environment serves, the state `deploying`, and the environment's hostname under the current label. For a server application, it also carries `health_path`, the recorded manifest's health path as the health gate will probe it, cut at 256 characters (PLD-L0-63). A serverless application's restart answer omits that member. The action record holds the outcome `deploying` (MAPI-06), and its refusals are the platform redeploy's, each a row of `schemas/wire_errors.json` (PLD-L0-84; MAPI-15). On the operator's restart of another account's application (PLD-L0-84), the answer carries no `health_path`, since the path is what the tenant's manifest wrote (ADM-L0-10).

MAPI-25: `check_deploy` is one row of the enumeration on the `environment` resource at the observe tier (API-L0-24). Its request carries `application`, and optionally `local_path`, each admitted and refused as `deploy_command` admits and refuses it. Its answer, status 200, carries the contract version, the application, the environment a deploy would target, `refusals`, `checks`, `zip_checked`, `kind`, `credentials_missing`, `provider_credentials_missing`, `first_deploy`, `recorded_health_path`, `last_release`, `without_command`, `fallback`, `command`, `command_windows`, `command_npx`, and `command_npx_windows`, which a hosted connector's session leaves out (PLD-L0-107), `detail`, and `page`. Each entry of `refusals` carries a refusal's name, status, and detail, the detail within a refusal's budget, and the refusal's `next` where it carries one (MCP-12; PLD-L0-107; MAPI-24). The call is refused as the deploy's start refuses the application, the manifest, the environment, and a deletion in flight, each a row of `schemas/wire_errors.json` (MAPI-15). It is admitted under the credentials `deploy_command` admits, and under no transfer grant.

MAPI-26: `deploy_files` is one row of the enumeration on the `environment` resource at the reversible tier (API-L0-25). Its request carries `application`, and optionally `environment`, admitted and refused as `deploy`'s, `wait_seconds`, read on a call that starts the deploy alone, `file`, and `files`, naming one or both of the last two. It optionally carries `check_only`, a boolean read as false where absent. `file` carries `path`, `content`, and optionally `sha256` and `encoding`; each entry of `files` carries `path` with one or both of `content` and `sha256` and optionally `encoding`, or `path` with `stored` and optionally `sha256`.

This paragraph states `encoding`. It is `utf-8`, read where absent, for content that is the file's text, or `base64` for content that is the file's bytes in base64, such as an image, an icon, or a font. A `base64` content is decoded before any check, so the 512 KiB, the 4 MiB, and `sha256` are held to the decoded bytes. A JSON, JavaScript, or TypeScript file's syntax is read on its decoded text. An `encoding` of another value, a `base64` encoding beside no content, and a content that is not strict base64 are refused 400 `invalid_request`, naming the entry or `file`. A request's body is held to 4 MiB on the actions route and the tool surface alike, so one call carries about 3 MiB of a binary file's bytes as base64; a file kept by an earlier call is named by its `sha256`.

This paragraph states the keep's reach. A file kept for one of an application's environments is held for its other too. A call that names it by `sha256` alone reads it from the environment that keeps it, its writer and its hash checked, and keeps it again under the call's own environment. So a development environment added after production re-sends no file production still keeps. No file is carried while the application's stored data is over (OST-L0-05), so a hash the target lacks then reads missing.

A call that starts nothing answers status 200 with the contract version, the application, the environment, the state `file_kept`, `awaiting_files`, or `files_checked`, and `kept`, `missing`, `left_out`, `warnings`, `content_notice`, and `detail` where it carries them. A call that starts the deploy answers as `deploy`'s start answers, with `left_out`, `warnings`, and `content_notice` beside it, and `next` while it is still deploying.

`content_notice` stands where text the call carried holds U+FEFF, naming the first such file and its line; it refuses nothing. Where the character is the file's first, the notice says that some JSON parsers reject a leading mark. Otherwise it says that the character may be harmless in code but its context needs checking.

Each form says how to send a literal escape safely in the call's JSON and to check the file's SHA-256. The notice reads the character's position, not its parsed code context. It is at most 200 code points, with its path cut to fit, and names how many other files hold the character.

`artifact_notice` also stands on `files_checked` and on a started deploy where the root `package.json` declares something to install and the list sends no root `package-lock.json` or `npm-shrinkwrap.json`; it refuses nothing.

The `awaiting_files` detail, and a `deploy_files_hash_mismatch` detail for a sent `file` or content entry beside the hash received, name the common causes of a hash that misses: line endings, a trailing newline, or a byte-order mark. The platform never changes a file's bytes. It is admitted under the credentials `deploy_command` admits, and under no transfer grant, and it mints and answers no grant.

The `file_kept` and `awaiting_files` details ask for every file the deploy includes, the folder's package-lock.json among them where it has one, since the deploy installs from it.

This paragraph states the call's refusals, each a row of `schemas/wire_errors.json` (MAPI-15). A path is refused 400 `invalid_request` where it is absolute, names a drive, holds a backslash or an empty, `.`, or `..` segment, or passes 1,024 characters. So are a path listed twice, a server's list with no root `package.json`, and a `file` whose path holds a segment the zip leaves out. A `file` over 512 KiB of bytes, a list over 200 entries, and listed, stored, and filled files over 4 MiB in all are refused 413 `deploy_files_too_large`, its `limit` naming the cap. A `file` whose content's SHA-256 is not the `sha256` it names is refused 409 `deploy_files_hash_mismatch`, the per-file form of the deploy line's `upload_hash_mismatch`. A JSON, JavaScript, or TypeScript file that does not parse is refused 422 `deploy_files_syntax_error`. A refusal of one file names its path, and a refused `file` is not kept.

This paragraph extends the refusals to a list's contents. An entry of `files` carrying `content` is refused as a `file` is: by a path segment the zip leaves out, by its 512 KiB, by a `sha256` its content does not match, and by its syntax. Every content entry that passes its own checks is kept, though another entry of the list is refused. A `file` the same call carries is kept first, and stays kept.

This paragraph states a list's per-entry refusal. Where any content entry or stored entry is refused, the call answers the first refused entry's refusal in the list's order, its body also carrying `kept` and `refused`. Its `kept` gives each kept entry's `path` and `sha256`, and each entry by `sha256` alone whose file the platform holds, save one the zip leaves out or one whose file the platform could not read as the refusal was built. Its `refused` gives each refused entry's `path` and refusal name, and both follow the list's order. A hash-refused entry also names `received_sha256`. After a hash, syntax, or left-out refusal, or a stored entry's `artifact_area_mismatch` or `artifact_not_found`, the detail teaches the retry: the list sent again, each kept file by its `sha256` and each refused file corrected. That retry detail alone also says that the files that passed, and those earlier calls kept, are held now.

This paragraph states a stored entry. An entry of `files` may carry `stored`, naming a storage area's `area` and a file's `name`, with no `content` or `encoding`. The platform reads the file from the deploy target's partition of the area through `deploy`'s own read of a stored file (PLD-L0-63; OST-L0-03). It keeps the bytes under their SHA-256 as a content entry's are, and holds them to no 512 KiB bound. Every answer that is no refusal gives each stored entry it read by its `path`, `area`, `name`, `size`, and `sha256` under `stored`.

This paragraph states a stored entry's total. Each stored size is read from the file's metadata first. Where the stored sizes and the content entries' bytes pass 4 MiB, the list is refused `deploy_files_too_large` before any stored body is read. A stored body whose length is not the size its metadata gave is refused alike. Nothing of a stored entry is kept, while the content entries that passed their own checks and a `file` the call carries stay kept, as the total cap leaves them.

This paragraph states a stored entry's refusals, each falling in the list's order under the per-entry refusal above. An area the account has not declared, an area bound to another application, and the platform-held deploy area are refused 403 `artifact_area_mismatch` before any byte is read. No file of the name in the partition is refused 404 `artifact_not_found`, its detail naming the application's page on the signed-in site, where the person uploads it. Stored bytes a given `sha256` does not match are refused 409 `deploy_files_hash_mismatch`, and the file is not kept. A stored entry whose path the zip leaves out is answered under `left_out` and never read.

This paragraph states when the other refusals answer. Every call first answers the deploy's preamble refusals. A `file`, a list carrying contents, and a list naming a stored file are refused 429 `usage_over_quota` while the application's stored data is over (OST-L0-05). A call keeps its `file` and its list's contents before its list is read, so a refusal after that, the total cap or the start's own, leaves them kept. A list call answers PLD-L0-86's refusals that read no artifact before `missing`, in the start's words, `library_entry_not_served` after `missing` and before the total cap, and `file_dependency_not_sent` after the total cap.

This paragraph states the library fill. A list call fills a library entry's copy where its root `package.json` declares `@turnzero/<name>` as a `file:` path in `dependencies`, the recorded manifest's `packages` names the entry, and the list holds no path under that path. The fill places the entry's `package.json` and `lib/` files, read from the library (LC-05), under that path as `library take` does. The path is read with no `./` and no trailing slash, and one the zip leaves out, or one `invalid_request` would refuse, is filled with nothing. The manifest read is the record the call's preamble admitted. A declaration in any other section is neither filled nor refused, and an entry with no compiled modules is filled with nothing.

This paragraph states the fill's refusal and its answer. Where the fill's three conditions hold, a row whose version is not the one the library serves, or which names no served entry, is refused 409 `library_entry_not_served`. The detail gives the manifest's `packages` row, the copy's path and the remedy of listing the project's own copy in `files`. Where the library serves the entry, the detail also gives its version and two routes: take it with `library take`, or set the manifest row to that version, then `submit_manifest` and send the list again. If the library serves no entry, the detail says so. Filled files count toward the 4 MiB total and not toward the 200 entries. A call that starts the deploy also carries `filled` where it filled any, naming each entry filled by its `name`, `version`, and `path`.

This paragraph states a library copy the version would lack. Where the root `package.json` declares `@turnzero/<name>` in `dependencies` at a `file:` path other than the folder's root, the zip carries no file at or under that path, and the fill places no copy there, the call is refused 409 `file_dependency_not_sent` and nothing starts. Such a copy at a path the zip never carries, outside the folder or through a segment the zip leaves out, is refused alike. Every other `file:` dependency is neither filled nor refused, since a build may bundle it. The detail gives the remedy, then the reason with the package's name: no `packages` row names the entry, the list gives only paths the zip leaves out under that path, or the entry has no compiled modules.

This paragraph states `check_only`. A list call carrying it true keeps and checks its files as it would without it, builds the same zip, and runs the start's checks on it through the start's own path (PLD-L0-63). Those are the zip's checks, the health-path reading, the state checks, and the refusals that read no artifact. A refusal answers as the deploy's would, under `deploy_files`. Where none refuses, the call answers status 200 with the contract version, the application, the environment, and the state `files_checked`. It also carries the notices the deploy's answer would carry, `left_out`, `warnings`, `filled` where it filled any, `kept`, and `detail`. `kept` names each file's `path` and kept `sha256`, as a refusal's `kept` does. It writes no version row, counts no deploy of the day, builds no image, and acts on no environment. A deploy of the same zip already in flight refuses nothing.

This statement records a use of MAPI-02's shape clause on `deploy_files_too_large`'s member `limit` in `schemas/wire_errors.json`: the row gains the member, naming the cap the refusal met, and `schemas/wire_error.schema.json`'s member region is generated again from the rows. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

This statement records a use of MAPI-02's shape clause on the members `kept` and `refused` in `schemas/wire_errors.json`, on the rows `deploy_files_syntax_error`, `deploy_files_hash_mismatch`, `deploy_files_too_large`, and `invalid_request`. Each row gains the two members, naming a list's content entries kept and refused, and `schemas/wire_error.schema.json`'s member region is generated again from the rows. The platform then held 1 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

This statement records a use of MAPI-02's shape clause on `deploy_files`' response members in `schemas/action_payloads.json`: `kept`, an object, may also be an array, which a passing `check_only` answers, and `content_notice` is new. It also records the use on the member `received_sha256` of each `refused` item in `schemas/wire_errors.json`, on the rows `deploy_files_hash_mismatch`, `deploy_files_syntax_error`, `deploy_files_too_large`, and `invalid_request`, and `schemas/wire_error.schema.json`'s member region is generated again from the rows. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

This statement records a use of MAPI-02's shape clause on the members `kept` and `refused` of the rows `artifact_area_mismatch` and `artifact_not_found` in `schemas/wire_errors.json`, and on `deploy_files`' answer member `stored` in `schemas/action_payloads.json`. Each row gains the two members, naming a list's entries kept and refused, and `schemas/wire_error.schema.json`'s member region is generated again from the rows. The platform then held 3 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

MAPI-27: The development purge is one row of the enumeration on the `account` resource, reversible tier, marked `grant: super_admin` (MAPI-09; API-L0-12). For each of the calling account's own applications it names it runs the deletion walk `delete_application` runs after approval (PLD-L0-66), with no pending action and no browser approval. That tier is decided here on the row's own ground: the applications are the caller's own, on the development estate, which holds no customer's account or data (PLD-L0-85).

The request names `applications`, one or more application ids, and no other member; another shape is refused 400 `invalid_request`. An id the calling account does not hold, unknown or another account's alike, answers the state `not_held` and walks nothing. The two are told apart for nobody here, though `delete_application` refuses them by their own names, `no_such_application` and `application_other_account` (MAPI-14). Where one of the caller's own named applications carries a standing deletion marker, the whole request is refused 409 `deletion_in_progress` naming it and nothing starts; the retry is `delete_application` with its approval (PLD-L0-66). Otherwise the call answers 202 at once with each application's state, `walking` or `not_held`, and the walks run detached (MAPI-04).

MAPI-28: Two rows of the enumeration make one HTTP request to a route of the caller's own deployed application, each on the `environment` resource at the reversible tier (API-L0-26). `request_route` sends `GET`, and `write_route` sends `POST`, `PUT`, `PATCH`, or `DELETE`. So a host, and a person approving a call, can tell a read from a write by the tool. One handler answers both, and every guard, bound, and answer this statement states holds for both.

Each request carries `application` and `path`, and `write_route`'s also carries `method`. `request_route` defaults `environment` to `production`; `write_route` requires it, and an omitted value is refused `invalid_request` naming `environment` before any request. `request_route`'s optionally carries `method`, whose one value is `GET`, `GET` where absent. The path begins with one `/`, runs to at most 2,048 characters, holds no space or control character, and may carry a query. The request optionally carries `headers`, at most 16, each value a string of visible characters, spaces, and tabs, and `follow_redirects`, a boolean, true where absent. `write_route`'s optionally carries `body`, at most 64 KiB.

A call that sends a method through the other row is refused `invalid_request` naming the row that sends it. `request_route` refuses any `method` but `GET` naming `write_route`, at the top level and in an entry of `routes`. It declares no `body` at either place, and its `x-retired` sentence names `write_route` (MAPI-22). `write_route` refuses a `method` of `GET` naming `request_route`, and refuses an absent or other `method` naming its four. On the tool surface, a single tool call naming a `method` its row does not admit is handed to the dispatcher ahead of the argument layer, as MAPI-22's call is, so this refusal answers it, each row named as the connection lists it.

The caller may not set these headers, each refused `invalid_request` naming the header:
- `accept-encoding`;
- the hop headers `host`, `content-length`, `transfer-encoding`, `connection`, `keep-alive`, `upgrade`, `expect`, `forwarded`, and `via`;
- any name beginning `x-forwarded-`, `x-azure-`, `x-fd-`, `x-envoy-`, `x-k8se-`, `x-ms-containerapp-`, `x-turnzero-cloud-`, or `x-app-cloud-`, the families EGW-L0-03 removes.

The one name of those families the caller may set is `x-turnzero-cloud-client`, the app's client-version header (SVC-L0-11), which reaches the application as sent, so a route check meets a native client's version gate as the client does.

The plane composes the address from the environment's managed hostname under the estate's serving suffix (SVC-L0-07) and takes no host from the caller. It resolves the name, admits public unicast addresses alone, and dials the address it checked (EGW-L0-01, its classes EGW-L0-13's). A name resolving to no address, or to an address outside public unicast, is refused `route_unreachable` before any connection. A redirect is followed only to the same hostname over `https` on port 443, at most five hops, each checked the same way. Any other redirect, one naming another port among them, is answered as the result, and so is every redirect of a request naming `follow_redirects` false, so a caller can check that a page redirects, with `redirects` 0. A 303 answering any method but `GET`, and a 301 or 302 answering a `POST`, is followed with a `GET` and no body.

The request carries the caller's headers and body, the client library's defaults where the caller sets none, and no header or credential of the platform's. `accept-encoding` is always `identity`, and a body the application encodes anyway is returned decoded. The answer, status 200, carries `contract_version`, `reference`, `application`, `environment`, `method`, `url`, `status`, `headers`, `body`, `body_encoding` (`utf-8` or `base64`), `body_bytes`, `truncated`, `redirects`, and `elapsed_ms`. `method` is the call's own, and `url` the last address requested. Without `routes`, the body is returned up to 64 KiB, or the lower `max_body_bytes`, counted after any decoding, past which the connection ends and `truncated` is true, and the call ends within 20 seconds, past which it is refused `route_unreachable` with the reason `timeout`.

Where `status` is 400 or more and the answered headers carry `x-request-id`, the answer also carries `detail`. It names the reads that find that request's records, the value and the request's start filled in, in the order the guide Read logs and counters gives. The first is one `read_logs` with the field `request_id`, no source, `since`, and `wait_seconds` 10, which returns a 5xx's router record and the entries the application wrote with a `request_id` field (MAPI-04). Then comes the source `container` from the same start, which needs no id, with `contains` only for a line that prints the value, because a console line carries the value only where the application prints it.

The request optionally carries `routes` in place of the members a single request sends: `method`, `path`, `headers`, and `follow_redirects`, and on `write_route` `body`. It is a list of one to five entries, each holding those members, checked as the single request's are, an entry's refusal naming its place. So a list runs under one row, and reads and writes together take two calls. An entry may also carry `expect`, the status from 100 to 599 it is expected to answer, any other value refused `invalid_request` naming its place. A call naming `routes` beside any of those members is refused `invalid_request`.

The entries are requested in order, each counted as one call toward the account's sixty a minute, the one window both rows count in. With `test_end_user`, one sign-in serves every entry. Each entry keeps its 20-second bound, the whole list ends within 60 seconds, and each body is returned up to 12 KiB.

With `routes`, the answer carries `results` and `failed` in place of the single request's members from `method` to `detail`. Each result carries those members, or, for an entry refused `route_unreachable`, `method`, `url`, and `refused`, holding the refusal's `error`, `reason`, and `detail`, the next entry still requested. `failed` counts the results refused, those of an entry with `expect` answered with another status, and those of an entry without it answered with a status of 400 or more. Where `failed` counts an entry without `expect` that answered 400 or more, the answer also carries `note`, at most 200 Unicode code points. It gives the number of those entries and says to set `expect` to the intended status to count a matching result as passed. Refused entries answered no status and are excluded from this number. A result of an entry with `expect` also carries `expected`, true where its status equals it.

The request optionally carries `max_body_bytes`, a whole number from 0 to 65,536, which lowers the bound each body is returned up to, so a large page fits a tool's output limit. Under `routes` it never raises an entry's 12 KiB. At 0 the answer carries the status and headers with an empty `body`, `truncated` true where the application sent any byte. Any other value is refused `invalid_request` before the rate window and any request.

The request optionally carries `test_end_user`, a test end user's id or label as `sign_in_test_end_user`'s `end_user` takes it, with `environment` given (ACS-L0-21). It is admitted for the calling credential as the creation is (ACS-L0-21): refused `test_end_users_disabled` while `TEST_END_USERS` reads off. A minted token without the `test_end_users` grant is refused `test_end_users_not_admitted` on a production realm and on a workforce realm. The account's session and a token carrying the grant are admitted on every realm. A user who is not an unexpired test end user of the realm is refused `not_test_end_user`, an id no user holds `no_such_end_user` (MAPI-15), and an application declaring no accounts service `realm_not_declared`.

The plane signs the test end user in through the command's own sign-in, held to the address's sign-in limits (ACS-L0-12) and the realm's per-source rate on sign-in starts under the caller's source address (ACS-L0-07). The session lives at most 60 seconds. `request_route` and `write_route` optionally carry `session_as`, `cookie` or `bearer`, `cookie` where absent. With `bearer`, `Authorization: Bearer <value>` replaces the cookie on the request and each same-host redirect. Otherwise its cookie rides them. The plane ends the session when the call ends, answered or refused, waiting at most five seconds for the ending. A refused sign-in is refused by its own name: `signin_code_rate_limited` past the address's `code_sends_per_hour`, `signin_rate_limited` past the realm's `signin_starts_per_hour`, `user_suspended`, `route_not_enabled` where the realm admits no sign-in, `signin_code_invalid` where the held code does not confirm, or `invalid_request`.

Where the management and accounts services are separate processes, the sign-in and the ending run on the accounts service through its marked routes, as ACS-L0-21 states. A call that service does not complete or answers by no name of the sign-in's own, or one made where the secret or the address is absent, is refused `test_end_user_sign_in_unavailable` (503), signing nobody in and requesting nothing.

The plane replaces the session's value wherever it appears unencoded in the answered `url`, headers, and body, a `set-cookie` under the realm session's name among them. A value the application returns encoded, such as in base64, is not replaced. A `cookie` header beside `test_end_user` is refused `invalid_request`. A caller's `authorization` header with `session_as` `bearer` is refused likewise. A `session_as` without `test_end_user` or with any value other than `cookie` or `bearer` is refused `invalid_request` before any request.

One account makes at most 60 such calls a minute across both rows, past which the call is refused `rate_capped` (PLD-L0-67). The call refuses `no_such_application` for an id no account holds and `application_other_account` for another account's (MAPI-14). It refuses `environment_not_created`, and `never_deployed` (PLD-L0-59) where the environment serves no version. `route_unreachable` carries `reason`: `no_address`, `address_not_public`, `connect_failed`, `tls_failed`, or `timeout`. The record's subject is the application, the environment, the method, and the path, its query left out, each entry's for a list, and never the headers or the body (MAPI-06).

This statement records a use of MAPI-02's shape clause on `request_route`'s request, at the top level and in `routes` entries: `method` narrowed to the one value `GET`, and `body` removed, `write_route` sending what they sent. The owner approved the split, and `request_route` keeps its name. The descriptions in `schemas/action_payloads.json`, `schemas/management_api.json`, `schemas/mcp_surface.json`, and `schemas/wire_errors.json` move with it. The platform then held 6 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

MAPI-29: The support read token lets the support agent read one account's own state for one chat, only because the account's owner asked: a summary, and the wider reads below, each cut to an allow-list. It is a minted token carrying the one grant `support_read`, and nothing else mints it: `mint_token` refuses the grant as it refuses any grant outside its list (MAPI-14).

The management service serves the routes under `/api/v1/support/`, none of them a management action: the four this paragraph and the next three state, the wider reads the paragraphs after the summary state, and the Questions page's chat routes the paragraphs after the bounds state. The service also serves the hand-off route MAPI-35 states. `POST /api/v1/support/chats` answers a chat id: a public id `sc_` followed by 22 base64url characters, a dot, and an HMAC-SHA256 of the public id and an account's identifier under a key derived from the browser credential secret. Under the support cookie of a signed-in browser (WEB-L0-16), verified as the site gate verifies the site cookie, the id is signed for that account; otherwise it is signed for no account, and no grant attaches to it. The answer names `bot_check` and `visitor_chat` besides, as the chat paragraphs state.

`POST /api/v1/support/consent`, a same-origin JSON post under the support cookie of a signed-in browser naming `chat`, is the visitor's consent. A chat not signed for the cookie's account is refused 403 `chat_not_yours`, a request with no admitted cookie 401 `authentication_required`, and a suspended account 403 `account_suspended`, each with nothing minted. Otherwise the route revokes the chat's live support read token, if any, and mints one: account scope, the grant `support_read` alone, the label `Support chat <public id>`, and an expiry 60 minutes after the mint. It posts the token's value, the chat's public id, and the expiry to the support agent's bridge (the next paragraph). The answer names the chat's public id, the token's identity, and its expiry, and never the value.

Where the estate names no bridge or holds no browser credential secret, the route answers 503 `support_unavailable` with nothing minted; where the bridge does not answer 2xx within 5 seconds, the token is revoked at once and the route answers 502 `support_unreachable`.

The bridge is named by the settings `SUPPORT_BRIDGE_ORIGIN`, an https origin or http on a loopback host, and `SUPPORT_BRIDGE_SECRET`. Each call is a JSON post to `/support/account-grant`, `/support/account-grant/end`, `/support/chat`, `/support/chat/stream`, or `/support/chat/rate` (MAPI-32) carrying the header `x-turnzero-support-signature: t=<unix seconds>,v1=<hex>`, the HMAC-SHA256 of `<t>.<body>` under the secret. The bridge admits a call whose signature holds within 300 seconds of its clock. The token's value reaches the bridge alone: never the browser, a chat message, or the model.

`POST /api/v1/support/consent/end` naming `chat`, under the same cookie, revokes the chat's live support read token and tells the bridge to drop it, best effort. A browser's sign-out that ends a live session row of the account (ACS-L0-18), and `sign_out_everywhere`, revoke every live support read token of the account on every chat, and tell the bridge to drop each, best effort. A sign-out under a cookie whose row is already revoked ends nothing. `revoke_token` ends one as it ends any token, and `list_tokens` lists it, its label naming the chat. An account's erasure ends it with the account's other tokens (API-L0-05). On those last two ends the bridge is not told: the plane's refusal of the token is the authority.

`GET /api/v1/support/account` under the support read token as a bearer answers the public id of the chat the token was minted for, as `chat`, and one summary of the token's own account. The summary is cut to an allow-list from the readers the customer rows read, and holds these parts:

- the account's identifier, creation, standing and products;
- at most 20 applications, each with its identifier, name, label, size, state, serving version, creation, and each environment's name, state, serving version, and hostname; `unlimited` is present and true on the company's own applications alone;
- each application's production compute state, restart count, and server-error counts;
- each application's 5 newest versions' environment, number, kind, state, stamps, and, for one that did not succeed, the result, step, and error name alone;
- the usage period with each application's state, measures, and limits;
- `credit.grants`: at most 20 grants of this account, newest first, each holding these members:
  - `id`;
  - `source`;
  - `purchase`, the plane's purchase identifier or null;
  - `granted_at`;
  - `expires_at`;
  - `amount_micros`;
  - `left_micros`;
  - `spent_micros`.

A grant's spent amount is its amount less what is left and what removals took, net of restores, never below zero. The credit part answers no operator reason or name, no provider identifier, and no refunds member.

The summary never answers a secret or a setting's value, a token, a sign-in address, an identity, a passkey, an end user, a log line, a request path, build output, or a detail's free text. Any other bearer, or none, is refused 401 `authentication_required`, and a token of a suspended account 403 `account_suspended`.

The wider reads are `GET /api/v1/support/<read>` under the same token, each answering `chat` beside its cut. Each runs the existing action its customer row runs, an observe action or, for the issues read, `relay_issue_act`'s read acts alone, through the dispatcher under the token's own minted credential, and keeps only the members named here:

- `status` runs `read_status`. It answers the application's identifier, label, size, described environment, state, and serving version. `unlimited` is present and true on the company's own applications alone. For each environment it answers the state, compute state, restart count, serving version, hostname, and halt. It answers each deploy row's version, kind, state, and stamps, its outcome cut to the result, step, and error words. It answers the described environment's server-error counts, never their paths.
- `versions` runs `list_versions`: each environment's serving version, and at most 20 rows, each its environment, number, kind, state, whether it serves, stamps, and outcome words.
- `check` runs `check_deploy`: the application and environment checked, whether the upload was checked, and each refusal's name, status, the platform's sentence, and the next action's name.
- `logs` runs `read_logs` over at most the last 7 days and 500 entries, the answer within 200,000 characters. Each entry answers its instant, its level as a word or nothing, its source, its message, and its fields. Each message, field value, and console line is redacted: email addresses, telephone numbers, bearer values, JWTs, prefixed keys, and opaque strings of 32 characters or more but a UUID are replaced. A field whose name names a person or a credential is dropped whole, the name read in its words whether written with `_`, `.`, `-`, or camelCase. An answer past the bound is cut and marked truncated.
- `counters` runs `read_counters`: each bucket's name, start, and total.
- `settings` runs `list_secrets`, `list_storage_areas`, and `list_outbound_apis`, and, for a named application, `read_app_sign_in`, `read_push`, and `read_schedules`. It answers secret and setting names, scopes, applications, environments, stamps, and whether a restart is needed, never a value or a fingerprint. It answers each area's and upstream's name, kind, application, environment, and host. It answers the realm's sign-in methods, limits, invitation and session days, counts, secret names, and clients' identifiers and versions. It answers push's configuration flags, secret names, counts, and the month's accepted count and quota. It answers each schedule's name, cron, next due, whether it is deployed, and its run in flight, and of its last run and its 10 newest runs the trigger, stamps, outcome word, status, and duration, never a run's detail.
- `database` runs `query_database` with fixed statements the route alone composes: each `public` table's columns, types, and nullability, its index names, and the applied names in a migration table the common tools write. It never reads another row.
- `issues` runs `list_issue_spaces` and `relay_issue_act`: the account's own spaces of kind `account` that no application's binding record names, and in one of them the relayed `list`, `search`, or `read` alone. Any other space is refused 404 `not_found`, and any other act 400 `invalid_request` with nothing relayed. Each relayed call reads that one space at `view` under the support token's own identity. Restricted issues are absent from `list` and `search`; a `read` is refused 404 `issue_refused`, as for an identifier no issue carries. For `read`, the query's `issue` member names the issue. A relayed answer is the issue service's own, whole, within the answer's 200,000 characters.
- `files` reads the deployed files of the serving version or the one before it: the application's tree at /app in the version's image, read from the cell registry under the management identity. A file a newer layer deleted is not in that tree. It answers the file list, at most 2,000 files, or one page of one file: at most 400 lines and 40,000 characters, a longer line answered in pages within it, each answer naming where the next page starts. It never serves `node_modules`, an environment file, a binary file, or a file past 1 MB, and answers `not_found` where the image is no longer kept.

A wider read with no `application` where its action needs one is refused 400 `invalid_request`, and a refusal of the action it runs is answered under that action's own name and status, the management action surface's row. Where one of several actions a read runs is refused, as a part of `settings` or `database` may be, that part answers the action's name, status, and refusal name in place of its value. Where the estate holds no dispatcher seam or no image reader, a read answers 503 `support_unavailable`.

One support read token reads at most 30 times in a UTC minute. One chat reads at most 600 times in any 60 minutes, across every token the chat held, so a new consent click resets nothing. Each read of a route counts once against the token's minute, before any other read of the account. It then counts once against the chat's hour only where the chat's count stands below its bound. So a read either bound refuses never counts against the hour.

A read past either bound is refused 429 `support_read_rate_capped` with nothing read, and the refusal is recorded under the token's own identity. The answer carries `retry_after` and the header `Retry-After`, each the seconds to wait:

- past the token's bound, to the next minute;
- past the chat's bound, until enough of the chat's oldest counted minutes leave the trailing 60 for a read to pass.

The counts are rate windows keyed on the token's identity and on the chat's public id, shared across the plane's replicas as the admission window's are. So they may pass a bound by one flush interval's reads per replica, and the admission window counts each request by its source besides (PLD-L0-67).

The consent needs no fresh sign-in (MAPI-03; WEB-L0-16). It stands under the support cookie of the signed-in session, which a browser sends to `/api/v1/support/` alone. The token reaches that account's own observe reads, cut to the allow-lists above, and its deployed files, never a management action that writes and never past the account. Its only sending act is the hand-off MAPI-35 states. It ends at any of the account's browser sign-outs that ends a live session row, that session's among them.

`POST /api/v1/support/chats/message` is one message of the Questions page's chat. It is a same-origin JSON post naming `chat`, a chat id the chats route answered, and `text` of 1 to 4,000 characters. A signed-out message on an estate that names a bot check carries `bot_token` besides. A chat id of another form, or a text outside its bounds, is refused 400 `invalid_request`.

The route reads the support cookie as the consent route reads it. A chat signed for the cookie's admitted account is a signed-in chat, and the support application is told the account. A chat signed for no account is a signed-out chat, whatever cookie the request carries, and the application is told no account. A chat signed for neither is refused 403 `chat_not_yours` with nothing sent: a forged mac, or a chat started signed in whose session has since ended, been suspended, or signed out. So no signed-out message continues a signed-in conversation, and the page starts a new chat.

The bot check is Cloudflare Turnstile, named by the settings `SUPPORT_BOT_CHECK_SECRET` and `SUPPORT_BOT_CHECK_SITE_KEY`. On a signed-out message the route posts the token, the secret, and the visitor's address to Cloudflare's verification route. The check passes where the answer says so, and not otherwise. A message with no token, or one the check does not pass, is refused 403 `bot_check_failed`, and nothing is sent. A signed-in chat needs no check: its session is the check.

Where either setting is unset, the estate names no check, and a signed-out message runs unchecked, on either estate alike; the support application's caps bound it (the support member's statements). The chats route tells the page how a signed-out chat stands, as `visitor_chat`: `checked` or `unchecked`. It names the check's kind and public site key as `bot_check`, or null where the estate names none. The plane writes one diagnostics line, `support chat bot check off`, at its start where no check is named.

A message admitted is posted to the bridge's `/support/chat`, signed as every bridge call is, with:

- the chat's public id;
- the account, or null;
- the text;
- a turn id of the route's own, `st_` and 22 base64url characters;
- an address key, a hash of the request's source key under a fixed purpose word, so the application never holds an address.

A bridge that does not answer within 10 seconds is answered 502 `support_unreachable`. An estate naming no bridge or no browser credential secret answers 503 `support_unavailable`.

The route answers the browser a stream of server-sent events:

- `turn`, naming the turn, the chat's public id, and whether the chat is signed in;
- `progress`, the plane's own first line, then each line the application reports as the agent calls a tool;
- `draft`, the answer as the agent writes it, which a later `draft` or the first `text` replaces and which moves no offset;
- `text`, each part of the answer as it arrives;
- `done`, with the turn's end.

A message the application answers at once with a cap's or a failure's line is streamed `limit` or `failed` with that line, then `done`, with no further call. The caps are the support application's, and a message past one is the chat's answer, never a refusal.

The application holds one response open per watched turn at `/support/chat/stream` (support_agent:SUP-13), and the plane reads that response until `done`, with no read on a timer. Where the response drops, the plane attaches again by its offsets, 2 seconds later. A refused attach, or a response that ends with no event inside 30 seconds, says nothing of the turn. A run of them past 75 seconds ends the stream `failed` with the line that says to try again, and an attach answered 400, 401, or 403 ends it so at once. A response held 30 seconds or more that ends with no event is a healthy hold that dropped, and it ends the run.

A stream open 120 seconds ends with `timeout`. The page then reads the turn by `POST /api/v1/support/chats/stream`, a same-origin JSON post naming `chat`, `turn`, and optionally `text`, the characters of the answer it already shows. It answers the same stream past that offset, `turn` first, and 404 `not_found` where its first attach finds a turn the chat does not hold. Where a later attach finds that, the stream ends `failed` with the same line. A `done` with the state `superseded` ends the stream where the chat has moved to another turn. On these two posts the support cookie is read as the consent route reads it. A request with no cookie is a signed-out chat's, never refused for the cookie's absence.

A chat message writes no record row: the conversation's record is the support application's own log. The plane writes a diagnostics line for a failed bot check, `support chat bot check failed`, and for a bridge not reached, `support chat not delivered`, each naming the chat's public id and never the text.

The refusals `chat_not_yours`, `support_unavailable`, `support_unreachable`, `support_read_rate_capped`, and `bot_check_failed` are this statement's rows of `schemas/wire_errors.json` (MAPI-15), on its surface `support_read`, beside the rows of `authentication_required`, `account_suspended`, `rate_capped`, `internal`, `invalid_request`, and `not_found`, which name that surface too.

Each read writes operational record rows under the token's own identity (MAPI-06): the account, the credential kind `minted_token`, the token's identifier, the act, and the outcome. The summary's act is `support_read_account`. Each wider read admitted at the bounds writes one row as `support_read_<read>`, its outcome `completed` or the refusal's name. That row is written for a read refused before any action, and for one failing on the platform's side. Each action a wider read runs writes its own row besides, under its own name, as the dispatcher writes every call.

The consent and Stop sharing of a signed-in, active account each write a row under the browser session, which carries no identity of its own (MAPI-06), the acts `support_read_grant` and `support_read_end`, the outcome `completed` or the refusal's name. An end at a sign-out is that sign-out's own act and writes no row of its own. Each consent writes one control-plane diagnostics line, `support read granted` or, where the delivery failed, `support read not delivered`. Each token that a second consent in its chat, Stop sharing, a sign-out, or sign out everywhere ends writes `support read ended`; a token ended by `revoke_token` or erasure, or at its expiry, writes none. Each line names the account, the token's identity, and the chat's public id, never the value (system:LGS-L0-16).

MAPI-35: **The support agent's bridge can send a hand-off email for an account's chat under that chat's own support read token.** It calls `POST /api/v1/support/handoff` with that chat's support read token as a bearer. The route is no management action and appears in no AI tool list. It uses MAPI-29's support-read gate, including the token's minute and the chat's hour: a hand-off counts once against each bound. It grants no management write, writes no ledger row, and mints nothing.

The body admits `chat`, `asked`, and optional `purchase` alone. Any other member is refused 400 `invalid_request`, with nothing sent. The `chat` is an unchanged string of at most 64 UTF-16 code units and must equal the token's own chat; another is refused 403 `chat_not_yours`. The `purchase`, where present and not null, is an unchanged string of 1 to 64 ASCII letters, digits, underscores or hyphens. A malformed value is refused 400 `invalid_request`; a value naming no purchase of that account is refused 404 `not_found`.

The `asked` is a string. CRLF and CR line endings become LF. C0 controls other than tab and LF, DEL, and Unicode line and paragraph separators become spaces. The result is trimmed and must hold 1 to 2,000 UTF-16 code units, else the route refuses 400 `invalid_request`, with nothing sent.

The plane writes the recipient, reply address and subject. The recipient is the estate setting `SUPPORT_HANDOFF_MAILBOX`, the testing mailbox on development. Where it names no admitted mailbox, the route refuses 503 `support_unavailable`. The reply address is the account's earliest-bound verified address among those the balance warning reads, read at the send. The message names the account, chat and UTC day, the purchase where named, and what was asked. The purchase's part names its plane identifier, state, pre-tax amount and start instant, with the paid instant where one stands. The message carries no link; its HTML escapes every supplied value.

One email is admitted for an account in a UTC day, across its chats and tokens. Before sending, the plane claims the account and day's place under that key's lock. A pending claim is marked sent only after the sender takes the message. A sent claim answers 200 with `outcome: already_sent`; a pending claim answers 200 with `outcome: not_sent` and `reason: in_progress`. A successful send answers 200 with `outcome: sent`. No answer names the mailbox, reply address or claim.

A hand-off takes one place in ACS-L0-13's balance-warning window, counted under that window's turn. It takes nothing of the sign-in ceilings. A zero window or absent sender answers 200 `not_sent` with `reason: window_closed`; a full window answers `reason: window_full`. No verified reply address answers `reason: no_address`. A send that fails or times out after three seconds answers `reason: send_failed`. Where the sender has not confirmed acceptance, the plane releases any claim it took; the day's place stays free. After a timeout the provider may still deliver the email, so a later ask that day may send another.

Two claim faults remain. A failed release after a failed send leaves a pending claim; after sixty seconds that claim no longer holds the day's place. A failed sent mark after a taken send leaves a pending claim too: after sixty seconds a later ask may send another email. The plane prefers that duplicate to a lost hand-off.

The plane attempts to append an operational record naming the act `support_handoff` and its outcome under the token's identity (MAPI-06). If that append fails after a successful send, the route still answers 200 `sent`. If it fails after a send the sender did not confirm, the route still answers 200 `not_sent` with `reason: send_failed`. In either case it adds a diagnostic warning, and the operational record is absent. If the call attempted no send, an append failure still fails the call. The diagnostics name the account, token, chat and outcome. Neither record carries an address or the asked text. The claim is kept in the builder realm's account event log on ACS-L0-02's terms.

MAPI-30: `check_app_sign_in` is one row of the enumeration on the `realm` resource at the observe tier, read-only and open-world and not idempotent, since each call writes meter rows (ACS-L0-24). Its request carries `application` and `environment` (`production` where absent), and nothing else. The answer, status 200, carries `contract_version`, `reference`, `application`, `environment`, `sign_in_page`, `routes`, `detail`, and `page`, the guide Add work-account or Apple sign-in.

`sign_in_page` is the address of the realm's sign-in page the check requested. `routes` holds one entry for each of `entra` and `apple` the realm configures, in that order, and is empty where it configures neither. Each entry carries `name` and three objects, `credential`, `provider`, and `route`, each carrying `outcome` as ACS-L0-24 gives it. `provider` also carries `error` where it is `refused` and `status` where it is `unknown`. On Entra's `refused` and status-bearing `unknown` outcomes it also carries `code` where the first `error_codes` entry is a positive integer. The number can choose the step under ACS-L0-24. The outcome does not depend on it. Apple carries no `code`.

`route` also carries `status` where it is `not_serving` or `unknown`. An entry that needs a step carries `detail`, the step ACS-L0-24 gives for each of its outcomes needing one, in the order credential, provider, route.

Where a credential is `not_moved` and the recorded manifest's `realm` member gives that route's credential, the answer carries `next`: the one `submit_manifest` call with the application and the recorded manifest (MAPI-24). The answer's `detail` gives the routes checked and which of them need a step.

One account makes at most ten such calls a minute, past which the call is refused `rate_capped` before any credential is read, provider called, or page requested (PLD-L0-67). A check past the accounts service's window of ten checks a minute for each realm is refused `rate_capped` too. The call refuses `invalid_request`, `no_such_application` for an id no account holds and `application_other_account` for another account's (MAPI-14), `environment_not_created`, and `realm_not_declared` where the application declares no accounts service. Where a route goes to the accounts service and the build reaches none, or that service does not answer the check, the call is refused `realm_check_unavailable` (503), nothing checked (CRD-34). A route whose credential is `not_moved` goes to no accounts service, and neither does a realm configuring neither route.

MAPI-34: `check_manifest` is one row of the enumeration on the `application` resource at the observe tier (API-L0-24), read-only and not idempotent, since each call writes meter rows. Its request carries `application` and `manifest`, and nothing else. It runs the checks `submit_manifest` runs before its custom-domain write, through the one function the submission runs. It refuses as that submission refuses the application, the manifest, and a deletion in flight, each refusal naming `check_manifest` as its action. The custom-domain write's own refusal lies outside its reading, as the pages state. It records no manifest, writes no custom-domain row, runs no setup step, and mints nothing, and it is recorded as an action like every action (MAPI-06).

Its answer, status 200, carries the contract version, the application, `outcome` (`checked`), `changed`, `difference`, and `detail`. `changed` is true where the manifest differs from the recorded one or none is recorded. `difference` carries `added`, `removed`, and `changed`, each a list of paths in the form MAN-12's refusals name.

MAPI-32: **The Questions page's chat rates each answer through the plane, and each chat message names its browser by a hash, never by a value the support application could reuse.** `POST /api/v1/support/chats/rate` is a same-origin JSON post naming `chat`, `turn`, and `rating`, `up` or `down`. The route reads the support cookie and the chat id as the message route does (MAPI-29). It passes the chat's public id, the turn, and the rating to the bridge's `/support/chat/rate`, signed as every bridge call is, and answers the chat's public id, the turn, and the rating. A turn the bridge does not hold is answered 404 `not_found`. Another rating, or a turn id of another form, is answered 400 `invalid_request`. A bridge that does not answer is answered 502 `support_unreachable`. An estate naming no bridge, or a bridge answering 503, is answered 503 `support_unavailable`, and a bridge answering 400 is answered 400 `invalid_request`.

The message route keeps the support browser cookie, `__Host-turnzero_cloud_support_browser`: a random value of 22 base64url characters, HttpOnly, Secure, SameSite=Lax, on the root path, living 90 days. The route sets it where the request carries none of that form. Each message it posts to the bridge names a browser key, a hash of the cookie's value under a fixed purpose word, so the support application never holds the value. On a signed-in chat the message also names the account's creation time, the account row's `created_at`. The support application uses the two to name the account a browser's earlier chats led to. A synthetic account's message (ACB-L0-79) also carries `synthetic` true, and the support application keeps no row of it (support_agent:SUP-14). A rating not passed on writes one diagnostics line, `support chat rating not delivered`, naming the chat's public id and the turn and never the text.

MAPI-31: *Retired 2026-10-29 UTC.*

MAPI-33: The management actions are also served as an OpenAPI 3.1 document, generated with the human reference from the indexed sources (API-L0-09; CTX-03). The site render writes it at `/cloud/openapi.json` (PLD-L0-69).

It holds one `POST` operation for each action that has an entry in `schemas/action_payloads.json`, whose clients admit a bearer token and that carries no grant, with the action's request and response schemas and the `management_action` refusal names. Its `info.version` is `management_api.json`'s `version`. Its `servers` entry names the estate's tzCloud base, and each account or plane-made tzTrack row's path states the base its estate serves it at, each written from one map, so a change of an address moves it in one place.

MAPI-36: An action-registration module under `src/handlers/` exports only its register function. `buildAppParts` creates the registration context and passes it only to the register functions; the context appears on no exported object, `BuiltApp` included, and in no log. A handler that a module under `src/handlers/` registers can be called only through the action map and the dispatcher's checks of level, grant and approval (MAPI-04; MAPI-09; MAPI-11).

```
