Source: management_api_contract.md #

View this page as Markdown

On this page

Generated automatically from the published 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:
- 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).

Source Markdown #

---
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).