@zarel-ai/sdk 0.6.0 → 0.7.0

package/dist/generated/runtime.d.ts

@@ -3,6 +3,37 @@
  * Do not make direct changes to the file.
  */
 export interface paths {
+    "/runtime/branding": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Tenant branding for the Desk shell
+         * @description Tenant-identity projection data — display name,
+         *     logo and accent colour — gated by AUTHENTICATION only: any verified
+         *     principal, including the always-present anonymous session, may read it.
+         *     It is not a policy-bearing entity, so there is no contract-policy match.
+         *
+         *     The tenant comes from the request host, never from the path or a
+         *     parameter, and is verified equal to the principal's token tenant. A
+         *     host that is not a tenant subdomain gets an opaque 404 rather than an
+         *     existence signal.
+         *
+         *     The body is NOT the standard envelope: this operation answers with the
+         *     branding object directly.
+         */
+        get: operations["getBranding"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/runtime/llm/services": {
         parameters: {
             query?: never;
@@ -12,7 +43,7 @@ export interface paths {
         };
         /**
          * List the LLM services the actor is authorized to use in `?scope=`
-         * @description FR-B02 no-leak: returns ONLY services for which the actor has a
+         * @description No-leak: returns ONLY services for which the actor has a
          *     `use` policy in the requested scope. There is no separate
          *     "all services" endpoint — operators see everything because their
          *     contract policies grant them `use` on every service.
@@ -37,9 +68,9 @@ export interface paths {
         };
         /**
          * Get one LLM service by name (only if authorized in `?scope=`)
-         * @description FR-B02 no-leak: a service the actor cannot use in `?scope=` returns
+         * @description No-leak: a service the actor cannot use in `?scope=` returns
          *     404 indistinguishable from "doesn't exist". The response body never
-         *     reveals whether the row exists for unauthorized actors.
+         *     reveals whether the service exists for unauthorized actors.
          */
         get: operations["getLlmService"];
         put?: never;
@@ -78,35 +109,42 @@ export interface paths {
         };
         /**
          * Get masked metadata for one credential
-         * @description Plaintext is NEVER returned. Returns 404 indistinguishable from "doesn't exist" when not authorized (FR-B02).
+         * @description Plaintext is NEVER returned. Returns 404 indistinguishable from "doesn't exist" when not authorized.
          */
         get: operations["getLlmCredential"];
         /**
-         * Set / replace a credential (write-only on `api_key`)
-         * @description Body: `{ api_key, base_url? }`. Server encrypts with the per-tenant
-         *     DEK, computes a 4-char fingerprint, and writes a sanitised audit row
-         *     (no ciphertext / IV / fingerprint, FR-I06). The plaintext is consumed
-         *     and discarded — no read endpoint can retrieve it (FR-I04).
+         * Set / replace a credential (write-only on the secret)
+         * @description The body is `CredentialWriteBody` — the credential blob for the provider the DECLARED
+         *     service names, chosen by the path and not by a key you send: `{ apiKey, baseURL? }`, or
+         *     the AWS static-key shape for `bedrock`. The server encrypts it with the per-tenant data
+         *     encryption key, computes a 4-char fingerprint, and records a sanitised audit entry (no
+         *     ciphertext / IV / fingerprint). The plaintext is consumed and discarded — no read
+         *     endpoint can retrieve it.
          *
          *     Possible 4xx codes:
-         *       - `INVALID_API_KEY` (400): empty / too long / non-printable.
+         *       - `INVALID_CREDENTIAL` (400): the blob fails the resolved provider's schema — a missing
+         *         or malformed `apiKey`, or a key the shape does not declare.
          *       - `UNKNOWN_LLM_SERVICE` (404): service does not exist in catalog
          *         (only returned to authorized callers).
-         *       - `PROVIDER_NOT_ALLOWED` (403, ADR-0102 S5b-a): the service's
+         *       - `PROVIDER_NOT_ALLOWED` (403): the service's
          *         provider is outside the tenant's allowed providers (the bounds on
          *         the `manage_credentials` grant). Only reachable by holders of the
          *         grant — the no-leak 404 below still applies first.
+         *       - `PROVIDER_NOT_SUPPORTED` (409): the DECLARED provider is one the
+         *         server no longer supports. The request is well-formed and the actor
+         *         is authorized; what blocks it is the tenant's own stale state, so it
+         *         names the fix — update the declaration.
          *       - 404 indistinguishable from "doesn't exist" when the actor lacks
-         *         `manage_credentials` (FR-B02 / SEC.V12 — never 403).
+         *         `manage_credentials` (never 403).
          */
         put: operations["setLlmCredential"];
         post?: never;
         /**
-         * Remove a credential (FR-I07 safeguard)
+         * Remove a credential
          * @description Returns 409 `CREDENTIAL_IN_USE` when any active session is pinned to
          *     the service. Operators must close the pinned sessions first. Returns
          *     404 indistinguishable from "doesn't exist" when the actor lacks
-         *     `manage_credentials` (FR-B02).
+         *     `manage_credentials`.
          */
         delete: operations["deleteLlmCredential"];
         options?: never;
@@ -123,9 +161,9 @@ export interface paths {
         };
         /**
          * List masked metadata for the tenant's embedding credentials (per declared service)
-         * @description Returns one masked-metadata row per stored (tenant, embedding service).
+         * @description Returns one masked-metadata entry per embedding service with a stored credential.
          *     Plaintext is NEVER returned. Authorization: tenant-level superuser;
-         *     unauthorized callers receive an empty list (SEC.V12 no-leak, never 403).
+         *     unauthorized callers receive an empty list (no-leak, never 403).
          */
         get: operations["listEmbeddingCredentials"];
         put?: never;
@@ -143,7 +181,7 @@ export interface paths {
             path: {
                 /**
                  * @description The DECLARED embedding-service name from `embeddings.services[]`
-                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     — not the provider. A provider is not an identity: two
                  *     services may share one, and the credential keys to a declaration that
                  *     exists. The provider is resolved from that declaration server-side.
                  */
@@ -153,35 +191,39 @@ export interface paths {
         };
         /**
          * Get masked metadata for one embedding service's credential
-         * @description Plaintext is NEVER returned. 404 indistinguishable from "not configured" when not authorized (SEC.V12).
+         * @description Plaintext is NEVER returned. 404 indistinguishable from "not configured" when not authorized.
          */
         get: operations["getEmbeddingCredential"];
         /**
          * Set / replace an embedding service's credential (write-only on the secret)
-         * @description Body is the credential blob for the provider the DECLARED service names —
-         *     `{ apiKey, base_url? }` for apiKey providers (gemini, openai,
-         *     anthropic-via-Voyage) or `{ accessKeyId, secretAccessKey, region,
-         *     sessionToken? }` for bedrock. The server resolves the provider from
-         *     `embeddings.services[]`, validates against that provider's registry
-         *     credential schema, encrypts with the per-tenant DEK, computes a
-         *     fingerprint, and writes a sanitised audit row. The secret is consumed and
+         * @description The body is `CredentialWriteBody` — the credential blob for the provider the DECLARED
+         *     service names: `{ apiKey, baseURL? }` for apiKey providers (gemini, openai,
+         *     anthropic-via-Voyage) or `{ accessKeyId, secretAccessKey, region, sessionToken? }` for
+         *     bedrock. The server resolves the provider from
+         *     `embeddings.services[]`, validates against that provider's
+         *     credential schema, encrypts with the per-tenant data encryption key, computes a
+         *     fingerprint, and records a sanitised audit entry. The secret is consumed and
          *     never retrievable.
          *
          *     Possible 4xx codes:
          *       - `INVALID_CREDENTIAL` (400): blob fails the resolved provider's schema.
          *       - `UNKNOWN_EMBEDDING_SERVICE` (404): no live `embeddings.services[]`
-         *         entry of that name — a secret must key to a declaration that exists
-         *         (FR-022). Only reachable by authorized callers.
-         *       - `PROVIDER_NOT_ALLOWED` (403, ADR-0102 S5b-a): the declared service's
+         *         entry of that name — a secret must key to a declaration that exists.
+         *         Only reachable by authorized callers.
+         *       - `PROVIDER_NOT_ALLOWED` (403): the declared service's
          *         provider is outside the tenant's allowed embedding providers (the
          *         bounds on the `manage_credentials` grant). Only reachable by grant holders.
-         *       - 404 indistinguishable from "not configured" when not authorized (SEC.V12 — never 403).
+         *       - `PROVIDER_NOT_SUPPORTED` (409): the DECLARED provider is one the
+         *         server no longer supports. The request is well-formed and the actor
+         *         is authorized; what blocks it is the tenant's own stale state, so it
+         *         names the fix — update the declaration.
+         *       - 404 indistinguishable from "not configured" when not authorized (never 403).
          */
         put: operations["setEmbeddingCredential"];
         post?: never;
         /**
          * Remove an embedding service's credential (soft-delete + sensitive wipe)
-         * @description Soft-deletes the row and wipes the sensitive columns; the
+         * @description Soft-deletes the credential and wipes its secret material; the
          *     embedding_similarity gate falls through on subsequent turns for that
          *     service. 404 indistinguishable from "not configured" when not authorized.
          */
@@ -205,7 +247,7 @@ export interface paths {
         put?: never;
         /**
          * Create a record
-         * @description ADR-0127 (Option B strict) — this bare surface serves ONLY verbs with no
+         * @description This bare surface serves ONLY verbs with no
          *     named action. A governed verb is rejected `400 action_required`; dispatch
          *     it via `POST /runtime/actions/{name}` instead.
          */
@@ -232,7 +274,7 @@ export interface paths {
         post?: never;
         /**
          * Delete a record
-         * @description ADR-0127 (Option B strict) — a governed verb is rejected `400
+         * @description A governed verb is rejected `400
          *     action_required`; dispatch it via `POST /runtime/actions/{name}`.
          */
         delete: operations["deleteRuntimeRecord"];
@@ -240,7 +282,7 @@ export interface paths {
         head?: never;
         /**
          * Merge-patch a record
-         * @description ADR-0127 (Option B strict) — a governed verb is rejected `400
+         * @description A governed verb is rejected `400
          *     action_required`; dispatch it via `POST /runtime/actions/{name}`.
          */
         patch: operations["patchRuntimeRecord"];
@@ -344,7 +386,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List transition requests (filter by status / role) */
+        /** List transition requests (filter by status / required role) */
         get: operations["listTransitionRequests"];
         put?: never;
         /** Create a transition request */
@@ -390,13 +432,13 @@ export interface paths {
         /**
          * Dispatch a YAML-declared action
          * @description Resolves `name` against the tenant's `actions[]`, derives the
-         *     underlying `(entity, verb)` pair, and dispatches through the existing
-         *     `RecordCrudService`. Returns the dispatched record (or `null` for
+         *     underlying `(entity, verb)` pair, and performs that record operation.
+         *     Returns the dispatched record (or `null` for
          *     `delete` verbs) plus a `resolved_via_action` telemetry tag.
          *
-         *     ADR-0127 — this is the governed dispatch surface: the resolved action's
-         *     identity is carried to the deterministic write floor, which evaluates
-         *     capability / phase / precondition / confirmation before persistence. A
+         *     This is the governed dispatch surface: the server evaluates the
+         *     resolved action's capability / phase / precondition / confirmation
+         *     rules before the write is saved. A
          *     blocked write returns a typed outcome (`422 phase_not_allowed` /
          *     `422 precondition_failed`); a write a `confirm` guard pauses returns
          *     `409 confirmation_required` (see the confirmation round-trip below).
@@ -458,7 +500,7 @@ export interface paths {
         };
         /**
          * List flow events (readonly)
-         * @description The appended flow lifecycle log — where per-step history lives (a run row
+         * @description The appended flow lifecycle log — where per-step history lives (a flow run
          *     carries none). Ordered by the hash chain's `seq`, which is the only total
          *     order the log has. Same visibility rule as `/runtime/flows/instances`:
          *     owner-scoped unless the caller holds `view_flows`, applied independently
@@ -527,11 +569,12 @@ export interface paths {
         head?: never;
         /**
          * Resolve a flow callback
-         * @description **Public endpoint.** The `id` is the opaque capability token supplied
-         *     to the external system at flow registration; no JWT is required.
+         * @description Resolve a pending callback with `{action: "complete", payload}` or
+         *     `{action: "fail", reason?}`. Answers the resolved `FlowCallback` in the
+         *     canonical envelope.
          *
-         *     Returns a **flat** `{success, message?}` ack (no `data`, NOT
-         *     envelope-wrapped) — the SDK returns it whole (codegen-unwrap: no-unwrap).
+         *     Requires authentication like every other operation here: a call without a
+         *     token is refused `401`.
          */
         patch: operations["resolveFlowCallback"];
         trace?: never;
@@ -543,10 +586,18 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List webhook subscriptions */
+        /**
+         * List webhook subscriptions
+         * @description THE SIGNING KEY IS NEVER RETURNED. Every read on this surface — this list, the item GET, the create and patch responses, and the delete response — answers `has_secret` (a boolean) and `header_names` (the configured header NAMES) in place of `secret` and `headers`.
+         *     `secret` is the HMAC key Zarel signs `X-Webhook-Signature` with, so a receiver verifying that header is verifying "this came from Zarel". `manage_webhooks` gates who may SET it; no response returns it. Header VALUES are withheld with it: they are tenant-supplied and a receiver-side bearer token is a plausible thing to find in one.
+         *     The key is masked rather than the reads gated: reads stay open to every authenticated actor in the tenant, and there is simply nothing secret left in them.
+         */
         get: operations["listEventSubscriptions"];
         put?: never;
-        /** Create a webhook subscription */
+        /**
+         * Create a webhook subscription
+         * @description Answers `has_secret` and `header_names` in place of `secret` and `headers`, like every read on this surface — see `listEventSubscriptions` for why. The signing key is accepted on the way IN and never returned on the way out.
+         */
         post: operations["createEventSubscription"];
         delete?: never;
         options?: never;
@@ -563,15 +614,24 @@ export interface paths {
             };
             cookie?: never;
         };
-        /** Get a subscription */
+        /**
+         * Get a subscription
+         * @description Answers `has_secret` and `header_names` in place of `secret` and `headers`, like every read on this surface — see `listEventSubscriptions` for why. The signing key is accepted on the way IN and never returned on the way out.
+         */
         get: operations["getEventSubscription"];
         put?: never;
         post?: never;
-        /** Deactivate a subscription */
+        /**
+         * Deactivate a subscription
+         * @description Deactivates the subscription and answers its `id` and nothing else. The stored subscription — signing key and header values included — is not returned.
+         */
         delete: operations["deactivateEventSubscription"];
         options?: never;
         head?: never;
-        /** Merge-patch a subscription */
+        /**
+         * Merge-patch a subscription
+         * @description Answers `has_secret` and `header_names` in place of `secret` and `headers`, like every read on this surface — see `listEventSubscriptions` for why. The signing key is accepted on the way IN and never returned on the way out.
+         */
         patch: operations["patchEventSubscription"];
         trace?: never;
     };
@@ -622,26 +682,32 @@ export interface paths {
         get: operations["listConversationSessions"];
         put?: never;
         /**
-         * Create a conversation session (no lazy creation per FR-C07)
-         * @description Body: `{ channel_name, roles_snapshot[], scope, llm_service?, user_name?, metadata? }`.
+         * Create a conversation session (no lazy creation)
+         * @description The body is `ConversationSessionCreateBody`.
          *
          *     The SERVER assigns `session_key` and returns it on the response. A body
-         *     that CARRIES one is refused `400` — a client-chosen key was guessable,
-         *     squattable by another tenant user, and an existence oracle. This block
-         *     documented `session_key` as a request field, so an integrator following
-         *     it wrote a client that was 400'd on every call; the SDK did exactly that
-         *     until the two halves were reconciled.
+         *     that CARRIES one is refused `400` — a client-chosen key would be guessable,
+         *     squattable by another tenant user, and an existence oracle.
          *
-         *     Precondition enforced (FR-C09, operations gate relaxed by ADR-0112):
+         *     Precondition enforced:
          *     the actor must have ≥1 authorized `use` policy on some service in
          *     `scope` — governed conversation is itself the value, so no entity/flow
-         *     operation is required. Possible 4xx codes: `INVALID_SCOPE` (400 — also
-         *     returned for any other malformed body, including one carrying
-         *     `session_key`), `SESSION_USER_MISMATCH` (403),
+         *     operation is required.
+         *
+         *     THE 400 CODE NAMES THE FIELD THAT WAS REFUSED:
+         *
+         *       - `INVALID_SCOPE`, `INVALID_CHANNEL_NAME`, `INVALID_ROLES_SNAPSHOT`,
+         *         `INVALID_LLM_SERVICE`, `INVALID_USER_NAME`, `INVALID_METADATA` (400)
+         *         — one per declared field.
+         *       - `INVALID_BODY` (400): the body is not a JSON object, or carries a key
+         *         the schema does not declare.
+         *       - `SESSION_KEY_NOT_ACCEPTED` (400): the body carries a `session_key`.
+         *
+         *     The other 4xx codes: `SESSION_USER_MISMATCH` (403),
          *     `SESSION_CHANNEL_MISMATCH` (403), `LLM_SERVICE_UNAUTHORIZED` (403),
-         *     `NO_AUTHORIZED_LLM_SERVICE_FOR_SCOPE` (403), `UNKNOWN_LLM_SERVICE`
+         *     `NO_AUTHORIZED_LLM_SERVICE` (403), `UNKNOWN_LLM_SERVICE`
          *     (404). `SESSION_KEY_CONFLICT` (409) is retained but unreachable short of
-         *     a UUID collision, since the caller no longer chooses the key.
+         *     a UUID collision, since the caller does not choose the key.
          */
         post: operations["createConversationSession"];
         delete?: never;
@@ -761,10 +827,10 @@ export interface paths {
         put?: never;
         /**
          * Recompute derived fields for every record of an entity
-         * @description Rewrites the computed fields of every `runtime.records` row of the
-         *     entity. ADR-0098 D9: this operates on RUNTIME state, so it lives on the
-         *     runtime plane alongside the MCP `recompute_entity` tool, which shares its
-         *     implementation and its authority (the `entities` contract section).
+         * @description Rewrites the computed fields of every record of the
+         *     entity. It operates on runtime state, so it belongs to the runtime API,
+         *     alongside the MCP `recompute_entity` tool, which has the same authority
+         *     (the `entities` contract section).
          */
         post: operations["recomputeEntity"];
         delete?: never;
@@ -784,16 +850,16 @@ export interface paths {
         put?: never;
         /**
          * Verify a channel binding
-         * @description ADR-0141 FR-031. Flips a channel binding from `unverified` to `verified` —
+         * @description Flips a channel binding from `unverified` to `verified` —
          *     the elevation signal channel-binding resolution reads.
          *
          *     Authorized by the `verify_channel_binding` runtime SYSTEM ACTION, and by
          *     nothing else: the caller needs no `update` grant on
          *     `records/channel_identities`. That is the point of the operation. The
-         *     binding entity is the product's declaration, so the tenant cannot extend it
-         *     with the role-gated transition it used to supply; verification was
-         *     previously a PATCH authorized by the generic entity `update` grant — the
-         *     same grant that reaches `user_name`, the field that decides who someone is.
+         *     binding entity is declared by the product, not by the tenant's contract,
+         *     so the tenant cannot add a role-gated transition to it; and the generic
+         *     entity `update` grant also reaches `user_name`, the field that decides
+         *     who someone is.
          *
          *     Only the three verification fields are written. The request body may carry
          *     `verification_method` (a free-form string recording HOW the binding was
@@ -818,9 +884,9 @@ export interface paths {
         put?: never;
         /**
          * Assign a role to a user
-         * @description ADR-0102 S4 (FR-016): owner-marked roles (the plan envelope) are
+         * @description Owner-marked roles (the plan envelope) are
          *     platform-managed — assigning a user to one is rejected. The assigned
-         *     user must exist as a live `users` record (DB user-existence trigger).
+         *     user must exist as a live `users` record.
          */
         post: operations["createRoleAssignment"];
         delete?: never;
@@ -844,7 +910,7 @@ export interface paths {
         post?: never;
         /**
          * Revoke a role from a user
-         * @description ADR-0102 S4 (FR-016): revoking an owner-marked assignment would
+         * @description Revoking an owner-marked assignment would
          *     destroy the tenant's envelope anchor — rejected.
          */
         delete: operations["deleteRoleAssignment"];
@@ -864,25 +930,52 @@ export interface paths {
         put?: never;
         /**
          * Send a natural-language message to the cognitive agent
-         * @description Service endpoint — not CRUD-derivable. The LLM orchestrator compiles
-         *     an intent, validates it against the tenant contract, and executes it
+         * @description Service endpoint — not CRUD-derivable. The LLM proposes an intent; the
+         *     server validates it against the tenant contract and executes it
          *     via MCP tools.
          *
-         *     SpecKit 010 / ADR-0087:
-         *       - Sessions are no longer lazily created — `session_key` MUST refer
-         *         to a session previously created via `POST /runtime/conversation/sessions`
-         *         (FR-C07). Unknown keys return `SESSION_NOT_FOUND` (404).
+         *     Sessions and services:
+         *       - Sessions are not created lazily — `session_key` MUST refer
+         *         to a session previously created via `POST /runtime/conversation/sessions`.
+         *         Unknown keys return `SESSION_NOT_FOUND` (404).
          *       - Optional `llm_service` overrides the session's pinned service for
-         *         this turn (FR-C04). Must be authorized for the actor in the
+         *         this turn. Must be authorized for the actor in the
          *         session's scope.
          *       - Possible error codes:
          *           - `SESSION_NOT_FOUND` (404): unknown `session_key`.
+         *           - `UNKNOWN_LLM_SERVICE` (404): `llm_service` names a service the
+         *             tenant's catalog does not carry.
          *           - `LLM_SERVICE_UNAUTHORIZED` (403): actor lacks `use` on the
          *             requested service in the session's scope.
-         *           - `INTENT_OUT_OF_SCOPE` (422): the LLM emitted an intent
-         *             outside the session's scope partition (FR-H06 backstop).
+         *           - `SESSION_PINNED_SERVICE_UNAUTHORIZED` (403): the session's
+         *             pinned service is no longer authorized for the actor, or has
+         *             left the catalog. The turn is refused rather than silently
+         *             swapped to another service.
+         *           - `INTENT_OUT_OF_SCOPE`: the LLM emitted an intent outside the
+         *             session's scope partition (a backstop check). NOT an HTTP status
+         *             — this one arrives as a `200` turn body with `success: false`
+         *             and `error` naming it, because the turn happened and its
+         *             OUTCOME is the refusal.
          *           - `NO_CREDENTIAL_CONFIGURED` (412): the resolved service has
          *             no credential configured.
+         *           - `CREDENTIAL_UNREADABLE` (412): the resolved service HAS a
+         *             stored credential and it cannot be parsed. A different
+         *             action from the one above — re-set a corrupt credential
+         *             rather than create a missing one.
+         *           - `PROVIDER_NOT_ALLOWED` (403): the resolved service's provider
+         *             is outside the tenant's plan bounds.
+         *           - `NO_AUTHORIZED_LLM_SERVICE` (403): the actor holds `use` on
+         *             nothing in the session's scope. The default (unpinned) path
+         *             reports the FIRST authorized candidate's own failure, so this
+         *             code is never used for a missing credential or an out-of-bounds
+         *             provider.
+         *           - `CONVERSATION_TURN_LIMIT` (429): the per-role turn cap for this
+         *             session or day is reached.
+         *           - `CONVERSATION_TOKEN_LIMIT` (429): the per-role token ceiling is
+         *             reached — per-session, per-actor-day or per-role-day.
+         *             A channel party is not a separate case: it is counted by these
+         *             same two limits, under its party identity.
+         *           - `BAD_REQUEST` (400): the body failed its schema.
          */
         post: operations["runtimeConversationSend"];
         delete?: never;
@@ -902,21 +995,21 @@ export interface paths {
         put?: never;
         /**
          * Mint a short-TTL anonymous party token (channel-ops)
-         * @description Service endpoint (ADR-0133 §B.4 / decision 5). One of the FOUR
+         * @description Service endpoint. One of the FOUR
          *     channel-ops routes, and the ONLY routes that accept a `channel`-class
          *     ingress credential (`token_class='channel'`). The asymmetry is
-         *     enforced by the class-aware pipeline: a tenant token is rejected here,
+         *     enforced both ways: a tenant token is rejected here,
          *     and a channel credential is rejected on every other runtime route.
          *
          *     The channel is taken from the CREDENTIAL, never from the body — a
          *     gateway can only ever mint into its own channel. The body is strict:
          *     `{ party_ref }` and nothing else. Any role/privilege claim alongside
          *     `party_ref` fails validation before the mint and returns 422
-         *     `MINT_CLAIM_REJECTED` (QI-003) — a channel names a party, it never
+         *     `MINT_CLAIM_REJECTED` — a channel names a party, it never
          *     grants that party authority.
          *
          *     The response is a **bare** body (no `{success,data}` envelope); the
-         *     SDK returns it whole (codegen-unwrap: no-unwrap).
+         *     SDK returns it whole.
          */
         post: operations["runtimeChannelsMint"];
         delete?: never;
@@ -934,13 +1027,13 @@ export interface paths {
         };
         /**
          * SSE liveness stream of new egress directives (channel-ops)
-         * @description Service endpoint (ADR-0133 §B.4 / decision 5) — the `subscribe`
+         * @description Service endpoint — the `subscribe`
          *     capability. Channel-ops route: `channel`-class credential only.
          *
          *     The stream is server-side filtered to the credential's OWN
          *     `(tenant, channel)`: a subscriber never observes another channel's
-         *     directive metadata (QI-006). Notification transport ONLY — durability
-         *     is the outbox + sweep, so a missed frame is never a lost directive.
+         *     directive metadata. Notification transport ONLY — directive durability
+         *     does not depend on the stream, so a missed frame is never a lost directive.
          *
          *     The wire is a `text/event-stream` carrying `channel.directive_created`
          *     frames whose `data` is `{directive_id}` — an id, never content. The
@@ -963,14 +1056,14 @@ export interface paths {
             query?: never;
             header?: never;
             path: {
-                /** @description Egress directive id (ADR-0133 §B.4) */
+                /** @description Egress directive id */
                 id: components["parameters"]["ChannelDirectiveIdPath"];
             };
             cookie?: never;
         };
         /**
          * Fetch (= claim) an egress directive and its content (channel-ops)
-         * @description Service endpoint (ADR-0133 §B.4 / decision 5) — the `fetch` capability.
+         * @description Service endpoint — the `fetch` capability.
          *     Channel-ops route: `channel`-class credential only.
          *
          *     **fetch = claim**: this single call takes the delivery lease AND
@@ -980,9 +1073,9 @@ export interface paths {
          *     (its stable lease identity) and expires after a bounded TTL, so a dead
          *     adapter cannot strand a directive.
          *
-         *     A directive addressed to another channel is 403 — never readable
-         *     (QI-006). The response is a **bare** body (no `{success,data}`
-         *     envelope); the SDK returns it whole (codegen-unwrap: no-unwrap).
+         *     A directive addressed to another channel is 403 — never readable.
+         *     The response is a **bare** body (no `{success,data}`
+         *     envelope); the SDK returns it whole.
          */
         get: operations["runtimeChannelsFetch"];
         put?: never;
@@ -998,7 +1091,7 @@ export interface paths {
             query?: never;
             header?: never;
             path: {
-                /** @description Egress directive id (ADR-0133 §B.4) */
+                /** @description Egress directive id */
                 id: components["parameters"]["ChannelDirectiveIdPath"];
             };
             cookie?: never;
@@ -1007,23 +1100,23 @@ export interface paths {
         put?: never;
         /**
          * Report (= ack) the terminal send result of a directive (channel-ops)
-         * @description Service endpoint (ADR-0133 §B.4 / decision 5) — the `report`
+         * @description Service endpoint — the `report`
          *     capability. Channel-ops route: `channel`-class credential only.
          *
          *     **report = ack**: the terminal transition plus the lease release.
          *     Idempotent under redelivery — re-reporting an already-terminal
-         *     directive returns its existing status unchanged (QI-005b).
+         *     directive returns its existing status unchanged.
          *
-         *     A terminal report also appends the `channel.egress` boundary row to
-         *     the `channels` hash chain (ADR-0133 §B.7 / FR-E01), metadata-only.
-         *     `provider_message_id` MUST already be hashed by the adapter
-         *     (FR-E03): an address-shaped value is refused by the audit schema
-         *     (QI-001) and the row is skipped rather than leaking an address.
+         *     A terminal report also appends a `channel.egress` boundary entry to
+         *     the `channels` hash chain, metadata-only.
+         *     `provider_message_id` MUST already be hashed by the adapter:
+         *     an address-shaped value is refused by the audit schema
+         *     and the entry is skipped rather than leaking an address.
          *
-         *     A directive belonging to another channel is 403 (QI-006); a lost lease
+         *     A directive belonging to another channel is 403; a lost lease
          *     is 409, so the adapter aborts rather than assuming success. The
          *     response is a **bare** body (no `{success,data}` envelope); the SDK
-         *     returns it whole (codegen-unwrap: no-unwrap).
+         *     returns it whole.
          */
         post: operations["runtimeChannelsReport"];
         delete?: never;
@@ -1050,7 +1143,6 @@ export interface paths {
          *       - resolve_{entity}_{field}_transition_request
          *       - list_{entity}_{field}_pending_transition_requests
          *     Structured per-trio metadata lives in `UserToolCatalog.transitions`.
-         *     See ADR-0081.
          */
         get: operations["runtimeToolsList"];
         put?: never;
@@ -1069,16 +1161,16 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Effective authorizations of the authenticated actor (ADR-0102 §6, S3b)
+         * Effective authorizations of the authenticated actor
          * @description Self-scoped introspection: returns what the authorization engine
          *     actually decides for the CALLING actor — assigned roles (+ implicit
          *     `self`), the contract sections they can manage (`update` policies),
          *     the runtime system actions they hold (e.g. `view_traces`,
          *     `manage_role_assignments`), and per-entity record permissions (actions +
          *     per-action field restrictions; `null` = all fields). Derived by the
-         *     same canonical resolvers the enforcement paths use, so the response
-         *     can never drift from enforcement. There is NO actor parameter —
-         *     identity comes exclusively from the verified token.
+         *     per-action field restrictions; `null` = all fields). Computed by the
+         *     same logic that enforces authorization, so the response can never
+         *     drift from enforcement. There is NO actor parameter —
          */
         get: operations["runtimeEffectiveAuthorizations"];
         put?: never;
@@ -1104,10 +1196,8 @@ export interface paths {
          *     JSON-RPC message; the server replies either application/json or a
          *     text/event-stream (its choice per request). Authenticated by the same
          *     runtime tenant JWT as the REST API (aud='runtime-api',
-         *     token_class='tenant'), bound to the {tenant}.zarel.local subdomain
-         *     (canon §10.4 / ADR-0041). Spec-1 (mcp runtime-plane exposure) replaced
-         *     the fictional GET /runtime/mcp/stream SSE path with this POST transport
-         *     served by mcp-server-http.
+         *     token_class='tenant'), bound to the {tenant}.zarel.ai subdomain.
+         *     There is no GET /runtime/mcp/stream SSE path.
          */
         post: operations["runtimeMcp"];
         delete?: never;
@@ -1127,10 +1217,8 @@ export interface paths {
          * List MCP tools accessible to the authenticated tenant
          * @description Returns the MCP-layer `McpToolDefinition` list filtered to the tools
          *     the user can see. Dynamic state-machine trio entries appear as
-         *     first-class peers to entity-CRUD tools (ADR-0081). Transition tools
-         *     are emitted dynamically from the contract per-(entity, field); the
-         *     legacy closed set of three generic transition tools is removed (see
-         *     CHANGELOG for the transition).
+         *     first-class peers to entity-CRUD tools. Transition tools
+         *     are emitted dynamically from the contract per-(entity, field).
          */
         get: operations["runtimeToolsMcpList"];
         put?: never;
@@ -1201,17 +1289,15 @@ export interface paths {
         };
         /**
          * List API keys (masked metadata)
-         * @description Bounded fidelity declaration (see `createApiKey`). Returns a **bare**
-         *     array of masked key metadata — the SDK returns it whole (no-unwrap).
+         * @description Returns a **bare** array of masked key metadata — the SDK returns it
+         *     whole.
          */
         get: operations["listApiKeys"];
         put?: never;
         /**
          * Create an API key
-         * @description Bounded fidelity declaration for the three `/api-keys` endpoints the SDK
-         *     already calls (ADR-0109 codegen-unwrap follow-up) — NOT the broader
-         *     ADR-0072 `/api-keys` redesign. The response is a **bare** body carrying
-         *     the one-time plaintext `key`; the SDK returns it whole (no-unwrap).
+         * @description The response is a **bare** body carrying
+         *     the one-time plaintext `key`; the SDK returns it whole.
          */
         post: operations["createApiKey"];
         delete?: never;
@@ -1234,9 +1320,8 @@ export interface paths {
         post?: never;
         /**
          * Revoke an API key
-         * @description Bounded fidelity declaration (see `createApiKey`). Returns a **flat**
-         *     `{success:true}` ack (no `data`, not envelope-wrapped) — the SDK returns
-         *     it whole (no-unwrap).
+         * @description Returns a **flat** `{success:true}` ack (no `data`, not
+         *     envelope-wrapped) — the SDK returns it whole.
          */
         delete: operations["deleteApiKey"];
         options?: never;
@@ -1255,9 +1340,8 @@ export interface paths {
         put?: never;
         /**
          * Replay a state-machine instance against a new configuration
-         * @description Service endpoint (spec-051 US4 — moved from the legacy
-         *     `/workflows/replay`). The handler delegates to the MCP
-         *     `replay_workflow` tool and unwraps its JSON envelope.
+         * @description Service endpoint. Runs the MCP `replay_workflow` tool and answers
+         *     its result in the standard envelope.
          */
         post: operations["runtimeStateMachineReplay"];
         delete?: never;
@@ -1304,24 +1388,24 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Full chronology of one agent dispatch (Spec-020 US1)
+         * Full chronology of one agent dispatch
          * @description Returns the trace header (tenant, session, deployed spec version +
          *     hash, actor, flow, started_at, duration, outcome) plus the ordered
          *     `events[]` covering the eight pipeline stages: `topic_gate`,
          *     `intent_scoring`, `envelope`, `gatekeeper`, `preconditions`,
          *     `hitl`, `execution`, `audit`.
          *
-         *     ADR-0127 (US4) — the `gatekeeper` and `preconditions` events are emitted
-         *     from the deterministic write floor's REAL recorded verdict (`allowed` /
+         *     The `gatekeeper` and `preconditions` events are emitted
+         *     from the server's REAL recorded verdict (`allowed` /
          *     `denied` / `requires_confirmation`, with the typed reason and any failed
          *     preconditions), not inferred from the terminal outcome.
          *
-         *     Authorization (FR-006, originator gate): a trace is visible to its
+         *     Authorization (originator gate): a trace is visible to its
          *     originator and to superusers; everyone else gets `404
          *     trace_not_found` indistinguishable from a genuine miss.
          *
-         *     Pre-feature traces (FR-007): sessions originated before spec-020
-         *     deployment have no `trace_id` and return `404
+         *     Pre-feature traces: sessions originated before tracing was
+         *     deployed have no `trace_id` and return `404
          *     legacy_trace_not_available`. There is no retroactive backfill.
          */
         get: operations["getTrace"];
@@ -1341,19 +1425,15 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Paginated trace summary list (Spec-020 US1)
+         * Paginated trace summary list
          * @description Filters: `flow`, `user`, `from`, `to`, `outcome`, `limit` (default
          *     50, max 500), `cursor`. Returns `{ traces: TraceSummary[],
          *     next_cursor: string | null }`.
          *
          *     Visibility is applied where the page is CHOSEN, not after it: the
-         *     originator restriction runs in the query, before `LIMIT`, so every
-         *     row of a page is a row the caller may see and `next_cursor` — which
-         *     anchors on the last row — has nothing to disclose. (This
-         *     description previously said the cursor anchors at the last DB row
-         *     "visible or not". That was accurate about the old behaviour and
-         *     the old behaviour handed one caller another caller's `trace_id`
-         *     and `started_at` in cleartext.)
+         *     originator restriction is applied before the page limit, so every
+         *     trace in a page is one the caller may see and `next_cursor` — which
+         *     anchors on the page's last trace — has nothing to disclose.
          *
          *     `duration_basis` says WHICH WINDOW each timing field was measured
          *     over, because this endpoint and `GET /runtime/traces/{trace_id}`
@@ -1396,7 +1476,7 @@ export interface paths {
          * Re-run deterministic governance stages against the proposed spec
          * @description Body: `{ against_current_spec?: boolean }`. Returns side-by-side
          *     comparison of original vs replayed stages with `deterministic_match`
-         *     boolean and `stages_diverged[]`. The originator gate (FR-006)
+         *     boolean and `stages_diverged[]`. The originator gate
          *     applies — replay leaks the trace's content, so the same
          *     visibility rule that governs the trace fetch route applies here.
          */
@@ -1419,13 +1499,13 @@ export interface paths {
         /**
          * Download a signed evidence bundle (.tar.gz)
          * @description Streams the bundle as `application/gzip` with attachment
-         *     `Content-Disposition`. Contents per ADR-0090: `README.md`,
+         *     `Content-Disposition`. Contents: `README.md`,
          *     `trace.json`, `trace.pdf`, `spec/{deployed_at_execution.yaml,.hash}`,
          *     `entities_snapshot.json`, `replay_attestation.json`, `manifest.sig`
          *     (Ed25519 over the canonical JSON of `manifest.json` per RFC 8785).
          *
          *     Soft cap 50 MB / hard cap 200 MB after compression. Past the hard
-         *     cap returns `error.code = bundle_too_large` (FR-035a). Originator
+         *     cap returns `error.code = bundle_too_large`. Originator
          *     gate enforced same as trace fetch.
          */
         get: operations["getTraceBundle"];
@@ -1449,26 +1529,26 @@ export interface paths {
         };
         /**
          * Download a signed audit tamper-evidence bundle (.tar.gz)
-         * @description ADR-0108. Streams a self-contained, offline-verifiable evidence bundle
+         * @description Streams a self-contained, offline-verifiable evidence bundle
          *     for the tenant's `{log}` cryptographic hash-chain as `application/gzip`
          *     with attachment `Content-Disposition`. Contents: `events.json` (the RAW
-         *     event content + chain columns `seq`/`prev_hash`/`event_hash`, so the
+         *     event content + chain fields `seq`/`prev_hash`/`event_hash`, so the
          *     verifier recomputes the canonical bytes itself), `checkpoints.json` (the
-         *     covering Ed25519-signed checkpoints), `anchors.json` (ADR-0115: external
+         *     covering Ed25519-signed checkpoints), `anchors.json` (external
          *     RFC 3161 TSA anchors over the checkpoints' Merkle roots + this tenant's
          *     inclusion paths — present only for already-anchored windows; absent
          *     windows verify as the un-anchored tail), `README.md`, `manifest.json` +
          *     `manifest.sig` (Ed25519 over the canonical JSON of the manifest, which
-         *     hashes every file incl. `anchors.json`, ADR-0090). Verify offline with
+         *     hashes every file incl. `anchors.json`). Verify offline with
          *     `zarel verify <bundle> --keys <trust-keys.json>` (add `--tsa-roots
-         *     <pinned.pem>` to also verify external anchoring, ADR-0115).
+         *     <pinned.pem>` to also verify external anchoring).
          *
          *     Authorization: gated by the `view_traces` runtime-system action (an
          *     evidence bundle exposes the full event content for the tenant, same as
          *     the trace bundle). An unauthorized actor receives an opaque 404. Tenant
          *     is taken from the verified JWT, never the path.
          *
-         *     Bounded read (ADR-0108 follow-up): the optional `from`/`to` query
+         *     Bounded read: the optional `from`/`to` query
          *     parameters restrict the export to an inclusive `seq` range. A request
          *     whose selected range exceeds the per-bundle event cap is refused with
          *     `413` — narrow it via `from`/`to`. For a partial range, only checkpoints
@@ -1488,17 +1568,17 @@ export interface paths {
             query?: never;
             header?: never;
             path: {
-                /** @description The audit row-table to list. */
+                /** @description The audit log to list. */
                 log: "binding_violations" | "topic_refusals";
             };
             cookie?: never;
         };
         /**
-         * Paginated, filterable listing of a privacy-preserving audit row-table (GTM M1)
-         * @description Lists rows of the tenant's `{log}` audit table — `binding_violations`
-         *     (ADR-0106 Amendment A1, blocked field-binding parameter-injection
-         *     attempts) or `topic_refusals` (ADR-0107, blocked regulatory-boundary
-         *     refusals). Each row exposes only a non-reversible SHA-256 hash + a
+         * Paginated, filterable listing of a privacy-preserving audit log
+         * @description Lists entries of the tenant's `{log}` audit log — `binding_violations`
+         *     (blocked field-binding parameter-injection
+         *     attempts) or `topic_refusals` (blocked regulatory-boundary
+         *     refusals). Each entry exposes only a non-reversible SHA-256 hash + a
          *     deterministic PII-mask of the offending value — NEVER the raw value (it
          *     is never stored). Newest-first, cursor-paginated. Response body (inside
          *     the success envelope): `{ items: <row>[], next_cursor: string | null }`
@@ -1509,9 +1589,9 @@ export interface paths {
          *     Authorization + known-log are checked BEFORE filter validation, so an
          *     unauthorized actor OR an unknown log receives an opaque `404` — even with
          *     a malformed filter — and cannot probe filter validity. There is no
-         *     per-row originator gate: any holder of `view_traces` sees all tenant
-         *     rows. Tenant is taken from the verified JWT, never the path. Distinct
-         *     from `/runtime/audit/{log}/evidence` (ADR-0108), whose `{log}` is the
+         *     per-entry originator gate: any holder of `view_traces` sees all tenant
+         *     entries. Tenant is taken from the verified JWT, never the path. Distinct
+         *     from `/runtime/audit/{log}/evidence`, whose `{log}` is the
          *     event hash-chains `state_machine | flows`.
          */
         get: operations["listAuditLog"];
@@ -1531,7 +1611,7 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Public Ed25519 trust-keys manifest (ADR-0090)
+         * Public Ed25519 trust-keys manifest
          * @description Public, unauthenticated endpoint listing every bundle-signing
          *     public key (current + archived) keyed by `kid`. Standalone
          *     verifiers (`zarel verify <bundle>`) resolve the bundle's `kid` →
@@ -1594,10 +1674,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * List the authenticated end-user's own governance receipts (Desk Spec 3)
+         * List the authenticated end-user's own governance receipts
          * @description Lists the CALLER'S OWN governance receipts — normalized over the three
-         *     audit signals: topic refusals (ADR-0107), binding violations (ADR-0106
-         *     A1), and validation violations (ADR-0111). Each receipt is a discriminated
+         *     audit signals: topic refusals, binding violations,
+         *     and validation violations. Each receipt is a discriminated
          *     union by `signal` carrying a composite id (`<signal>:<uuid>`), the request
          *     correlation `trace_id`, a non-reversible `proof` (hash + masked value +
          *     contract version, per signal), and a per-signal `detail`. NEVER the raw
@@ -1622,8 +1702,475 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        /** @description Body of the governed action-dispatch surface. */
+        ActionDispatchBody: {
+            /**
+             * @description Required for read/update/delete verbs; null/omitted for create/list
+             *     (entity-level). Must be a POSITIVE integer or its decimal string;
+             *     otherwise the request is refused `400 record_id_required` naming the field.
+             */
+            record_id?: number | string | null;
+            /**
+             * @description Forwarded to the underlying entity intent. Open because its keys are
+             *     the target entity's fields, declared by the tenant contract and
+             *     judged there — not by this document.
+             */
+            payload?: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Accepted for wire compatibility; server-side deduplication is not yet
+             *     implemented, so the key currently has no effect.
+             */
+            idempotency_key?: string;
+            /**
+             * @description An operator note, as sent by `@zarel-ai/react`'s action-confirm
+             *     dialog and by the SDK's `client.actions.dispatch`. The server
+             *     currently ignores it; it is declared so that a request carrying a
+             *     note is accepted rather than refused with a 400.
+             */
+            notes?: string;
+        };
+        /**
+         * @description Envelope of the bulk record import. The envelope is closed; each item's
+         *     `data` is not, for the same reason `RuntimeRecordCreateBody` is not.
+         */
+        BulkImportBody: {
+            items: {
+                /** @description One record's fields, judged against the tenant contract for the path entity. */
+                data: {
+                    [key: string]: unknown;
+                };
+                /**
+                 * @description Attribution for the created record. A non-string value here
+                 *     is refused.
+                 */
+                owner_name?: string;
+            }[];
+            /**
+             * @description Omitted means `strict`.
+             * @enum {string}
+             */
+            mode?: "strict" | "best_effort";
+        };
+        /**
+         * @description The record's fields. THE KEY SET IS NOT FIXED BY THIS DOCUMENT and cannot
+         *     be: it is the field list the tenant's published contract declares for
+         *     `{entity_name}`, and both the keys and the values are validated against that
+         *     contract. That is why this schema is deliberately open.
+         */
+        RuntimeRecordCreateBody: {
+            [key: string]: unknown;
+        };
+        /**
+         * @description The fields to change, merged onto the stored record. Open for the same
+         *     reason as `RuntimeRecordCreateBody`, and distinct from it because a patch
+         *     requires nothing: a create's required fields come from the contract, a
+         *     patch's from the merge base.
+         */
+        RuntimeRecordPatchBody: {
+            [key: string]: unknown;
+        };
+        /** @description A webhook subscription. Validated by the same rules as the PATCH that updates one. */
+        EventSubscriptionCreateBody: {
+            event_name: string;
+            /**
+             * @description HTTPS, and not a private host. Which hosts count as internal depends on
+             *     deployment-configured exemptions, so the rule is described here rather than
+             *     published as a `pattern`.
+             */
+            webhook_url: string;
+            /**
+             * @description The HMAC key. Present ⇒ every delivery carries
+             *     `X-Webhook-Signature: sha256=<hmac>`; absent ⇒ deliveries are unsigned.
+             *
+             *     `minLength: 1` because an empty string would read as "a secret is set" and still
+             *     produce unsigned deliveries. Omit the key to have none.
+             */
+            secret?: string;
+            /**
+             * @description Extra headers on the outbound delivery. Values must be strings. Restricted names
+             *     are matched case-insensitively and by prefix, which is why the key rule is described
+             *     here rather than published as `propertyNames`. Restricted names are refused `400`:
+             *     `authorization`, `cookie`, `host`, `x-api-key`, `x-webhook-signature`, and the
+             *     `x-platform-` / `x-forwarded-` prefixes.
+             *
+             *     `x-webhook-signature` is restricted because it is the platform's own. A value supplied
+             *     here would not REPLACE the delivery signature — the two arrive as one header with two
+             *     values — so every delivery on the subscription would fail verification at the receiver
+             *     while carrying a correct signature.
+             */
+            headers?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * @description A merge PATCH over one subscription. At least one mutable field is required — a body
+         *     carrying none is refused *"Subscription patch body must include at least one mutable
+         *     field"*.
+         *
+         *     Keys outside this set are refused rather than accepted and ignored. The rule applies to
+         *     the request body only, not to values already stored on the subscription.
+         *
+         *     `null` on `secret` and `headers` CLEARS the stored value; absent leaves it alone. The two
+         *     are different requests.
+         */
+        EventSubscriptionPatchBody: {
+            /** @description Validated by the same rule as on create. */
+            webhook_url?: string;
+            /**
+             * @description `null` clears the HMAC key, and every later delivery is then unsigned. The empty
+             *     string is refused rather than treated as a second spelling of that: it clears the
+             *     key while reading as a value.
+             */
+            secret?: string | null;
+            /** @description `null` clears them. Same value rule and same restricted-name rule as create. */
+            headers?: {
+                [key: string]: string;
+            } | null;
+            is_active?: boolean;
+        };
+        /**
+         * @description Settling a suspended flow callback. `action` selects which other key is required, and the
+         *     two arms go in opposite directions: `complete` resumes the run on `payload`, `fail` does
+         *     not resume it at all.
+         */
+        FlowCallbackResolveBody: {
+            /** @enum {string} */
+            action: "complete";
+            /**
+             * @description The resolution the suspended run RESUMES on. Open because the key set is the
+             *     external system's, not this document's; it must be an object.
+             *
+             *     ONE KEY DOES NOT SURVIVE: an own `__proto__` property is dropped rather than
+             *     stored.
+             */
+            payload: {
+                [key: string]: unknown;
+            };
+        } | {
+            /** @enum {string} */
+            action: "fail";
+            reason?: string;
+        };
+        /**
+         * @description Assign a role to a user.
+         *
+         *     `expires_at`, when sent, must be a string; any other type is refused.
+         *
+         *     `granted_by` IS NOT ON THIS BODY: sending it is refused by name. The grantor is the
+         *     authenticated caller.
+         */
+        RoleAssignmentCreateBody: {
+            /**
+             * @description The user receiving the role. The SDK's input calls this `target_user_name`, to
+             *     distinguish the target from the actor, and maps it here.
+             */
+            user_name: string;
+            role_name: string;
+            /**
+             * @description A moment, as a string: `2027-01-01T00:00:00Z`, an offset form, or a bare
+             *     `2027-01-01`. Deliberately NOT `format: date-time`: that format is RFC 3339 only and
+             *     would exclude the date-only and naive forms this field accepts. A non-string is
+             *     refused.
+             *
+             *     AN IMPOSSIBLE DAY ROLLS OVER rather than being refused: `2026-02-30T00:00:00Z` is stored
+             *     as `2026-03-02`. An out-of-range MONTH is refused; an out-of-range day is not.
+             *
+             *     Omit the key for a grant that does not expire; that is the only way to ask for one.
+             */
+            expires_at?: string;
+        };
+        /**
+         * @description OPTIONAL: sending no body at all and sending `{}` are both accepted, because flipping a
+         *     binding to `verified` needs no payload. `required: false` on the operation is what says
+         *     the first one.
+         *
+         *     A BARE `null` IS NOT ACCEPTED: a top-level `null` body is refused with
+         *     `entity.parse.failed` and a 400.
+         *
+         *     What the body may carry is the METHOD that was used, recorded alongside the flip. Any
+         *     other key is refused.
+         */
+        ChannelBindingVerifyBody: {
+            /** @description How the binding was verified, recorded on the record beside the flip. */
+            verification_method?: string;
+        };
+        /**
+         * @description Re-evaluate one state-machine instance against a candidate configuration.
+         *     `instance_id` must be a non-empty string.
+         */
+        StateMachineReplayBody: {
+            instance_id: string;
+            /**
+             * @description The candidate configuration, OPEN by declaration: its keys are a state-machine
+             *     configuration validated at replay, not a shape this document knows. A non-object is
+             *     refused.
+             */
+            new_config: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * @description Bulk-import a tenant snapshot. `data` must be an object, and keys outside this set are
+         *     refused.
+         */
+        SnapshotImportBody: {
+            /**
+             * @description The snapshot. OPEN for the same reason `BulkImportBody`'s item `data` is: its keys are
+             *     the tenant's own records, validated against that tenant's contract.
+             */
+            data: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Omitted means `clean`.
+             * @enum {string}
+             */
+            mode?: "clean" | "restore";
+            /**
+             * @description Omitted means `fail-fast`.
+             * @enum {string}
+             */
+            validation_mode?: "fail-fast" | "collect-errors";
+        };
+        /**
+         * @description THE ARM IS CHOSEN BY THE PATH, NOT BY A KEY IN THIS BODY. The server reads the declared
+         *     provider of the service named in the path and validates the body against that provider's
+         *     credential shape. There is no discriminator property to send, which is why this is a
+         *     plain `oneOf` and not a `discriminator` mapping.
+         *
+         *     Every provider uses one of TWO credential shapes: an API key, or Amazon Bedrock's static
+         *     AWS keys.
+         */
+        CredentialWriteBody: components["schemas"]["ApiKeyCredentialBody"] | components["schemas"]["AwsStaticCredentialBody"];
+        /**
+         * @description Printable ASCII, no whitespace. The rule exists to catch the copy-paste mistake — a
+         *     leading or trailing space or newline — not to describe any provider's key format.
+         */
+        CredentialApiKey: string;
+        /**
+         * @description The API-key credential shape: gemini, openai and anthropic for both LLM and embedding
+         *     services, plus the embedding `local` provider.
+         *
+         *     Keys outside this set are refused: `{"apiKey": "…", "secretAccessKey": "…"}` on an
+         *     api-key service is refused rather than silently discarding the AWS key.
+         */
+        ApiKeyCredentialBody: {
+            apiKey: components["schemas"]["CredentialApiKey"];
+            /**
+             * @description Optional endpoint override. Must be HTTPS and must not point at a private or
+             *     reserved address. Not published as `format: uri` because that would state a weaker
+             *     rule than the one enforced.
+             */
+            baseURL?: string;
+        };
+        /**
+         * @description Amazon Bedrock's static AWS keys, on both registries. The primary
+         *     secret fingerprinted on write is `secretAccessKey`, not `accessKeyId`.
+         */
+        AwsStaticCredentialBody: {
+            accessKeyId: string;
+            secretAccessKey: string;
+            region: string;
+            /** @description Optional — present for temporary credentials. */
+            sessionToken?: string;
+        };
+        /**
+         * @description A request to move one record field across a state-machine edge.
+         *
+         *     WHAT IT NAMES: the record (`entity_name`, `record_id`, `field_name`), the ask
+         *     (`requested_transition`), what the requester last saw (`current_state`), and an optional
+         *     `reason`. Nothing else — every value that decides who may approve the request is set by
+         *     the server.
+         *
+         *     THREE KEYS ARE NOT ON THIS BODY, and each is refused BY NAME with its reason rather
+         *     than accepted or silently ignored:
+         *
+         *       · `required_roles` — who may approve. Always derived from the edge's `allowed_roles`.
+         *       · `instance_id` — which state-machine instance the request belongs to, and so which
+         *         request an approval on the record resolves. Resolved from
+         *         (`entity_name`, `record_id`, `field_name`).
+         *       · `flow_instance_id` — ties the request to a suspended flow run, and a `rejected`
+         *         resolution on a linked request terminates that run. Set only by the server, when a
+         *         flow suspends on the request.
+         *
+         *     THE EDGE MUST BE DECLARED. A `current_state` → `requested_transition` the contract does not
+         *     declare for this entity/field is a 400.
+         *
+         *     Non-string values are refused, including inside a list and on `reason`.
+         */
+        TransitionRequestCreateBody: {
+            /**
+             * @description NON-EMPTY, and so are the three identifying strings below it: each names something the
+             *     request must be about.
+             */
+            entity_name: string;
+            /**
+             * @description A positive, signed 32-bit integer: at most `2147483647`.
+             *
+             *     A NUMBER only. `ActionDispatchBody.record_id` differs: it accepts a positive integer OR
+             *     its decimal string. This body takes the number only.
+             */
+            record_id: number;
+            field_name: string;
+            /**
+             * @description WHAT THE REQUESTER LAST SAW, checked against the instance's current state; a
+             *     disagreement is a 409 and no request is created. Kept in the body rather than derived
+             *     silently because a requester asking to move a record out of a state it is no longer in
+             *     has read stale data, and saying so is worth a key.
+             *
+             *     A STALENESS CHECK, NOT A COMPARE-AND-SET: a transition committed through another path
+             *     between the check and the write can still admit this request against the state the
+             *     record has left.
+             */
+            current_state: string;
+            requested_transition: string;
+            /**
+             * @description Required in practice when the matching edge declares `requires_reason`: an empty or
+             *     absent reason is then refused with the edge named.
+             */
+            reason?: string;
+        };
+        /** @description The inbound at-most-once dedupe token: a SHA-256 hex digest over the length-prefixed `(channel_name, channel_message_id)` pair, unique per `(tenant, channel)`. */
+        ChannelIdempotencyKey: string;
+        /**
+         * @description One governed conversation turn. Keys outside this set are refused.
+         *
+         *     In particular, these are refused: `role`; `locale` (the per-turn override is the
+         *     `?locale=` QUERY parameter, not a body key); and `metadata`.
+         */
+        ConversationSendBody: {
+            /** @description The natural-language turn. The empty string is refused, not sent. */
+            message: string;
+            /**
+             * @description REQUIRED. There is no lazy session creation: the key must name a session created
+             *     by `POST /runtime/conversation/sessions`, owned by the caller and not retired, or the
+             *     turn is `404 SESSION_NOT_FOUND`.
+             */
+            session_key: string;
+            /**
+             * @description Per-turn treatment-resolution overrides.
+             *
+             *     NO `channel_name`. The channel a turn is rendered for is the SESSION's, and it
+             *     is not caller-selectable: sending it is an unrecognized key and the turn is refused.
+             *     This matches `POST /runtime/conversation/sessions`, which answers
+             *     `403 SESSION_CHANNEL_MISMATCH` for a body channel that contradicts a party credential.
+             */
+            interaction?: {
+                /** @enum {string} */
+                audience?: "human" | "machine";
+                /** @enum {string} */
+                modality?: "synchronous" | "asynchronous";
+                platform?: string;
+                /**
+                 * @description The TREATMENT locale for this turn, overriding the configured treatment locale.
+                 *     Not the same as the `?locale=` query parameter, which sets the locale of labels
+                 *     and descriptions in the response and does not affect this override.
+                 */
+                locale?: string;
+                /** @description Per-turn timezone override for the turn's channel context. */
+                timezone?: string;
+            };
+            /**
+             * @description Per-turn override of the session's pinned service. Must be authorized for the
+             *     actor in the session's scope, or the turn is `403 LLM_SERVICE_UNAUTHORIZED`.
+             */
+            llm_service?: string;
+            /**
+             * @description The inbound dedupe token (see `ChannelIdempotencyKey`). Its SHAPE is validated for
+             *     every caller; what is conditional is what it is USED for. Dedupe applies only to a
+             *     party token, whose channel comes from the credential and never from this body — on an
+             *     ordinary tenant token a well-formed key is accepted and does nothing.
+             */
+            idempotency_key?: components["schemas"]["ChannelIdempotencyKey"];
+            /**
+             * @description The edge-attestation of the inbound crossing, from which the runtime
+             *     records the `channel.ingress` audit entry.
+             *
+             *     EVERY MEMBER IS OPTIONAL: recording the audit entry is fail-soft, so an attestation
+             *     missing `attested_by` skips the entry and the turn still commits.
+             */
+            channel_attestation?: {
+                /** @description Whether the adapter verified the provider signature. Only `true` counts as verified. */
+                signature_verified?: boolean;
+                /** @enum {string} */
+                attested_by?: "runtime" | "channel_provider";
+                /** @description The provider's clock for the crossing. */
+                provider_timestamp?: string;
+                /**
+                 * @description The opaque provider message id, which the adapter MUST hash if address-shaped.
+                 *     An address-shaped value is refused when the audit entry is recorded, and the entry
+                 *     is skipped rather than leaking PII.
+                 */
+                channel_message_id?: string;
+            };
+        };
+        /**
+         * @description Explicit session creation, the only way to open a session.
+         *
+         *     `session_key` IS NOT A PROPERTY: the server mints the key. A client-chosen one was
+         *     guessable, squattable under another identity, and an existence oracle. Sending it is
+         *     refused with a message that names the key and the reason.
+         */
+        ConversationSessionCreateBody: {
+            channel_name: components["schemas"]["NonReservedChannelName"];
+            /**
+             * @description The session-level snapshot of the actor's roles. NOT a security
+             *     gate: authorization is re-resolved server-side. It shapes the prompt given to the LLM.
+             */
+            roles_snapshot: string[];
+            /**
+             * @description Immutable for the life of the session.
+             * @enum {string}
+             */
+            scope: "runtime" | "contract";
+            /**
+             * @description Optional pin. Validated at create: unknown is `404 UNKNOWN_LLM_SERVICE`,
+             *     unauthorized in scope is `403 LLM_SERVICE_UNAUTHORIZED`.
+             */
+            llm_service?: string;
+            /**
+             * @description May only NAME THE AUTHENTICATED ACTOR — the route answers
+             *     `403 SESSION_USER_MISMATCH` otherwise. It is the identity that authorizes every later
+             *     read and write of the session, so a body that could choose it would let any
+             *     tenant user own someone else's transcript. Accepted rather than refused because clients
+             *     send it as an echo.
+             */
+            user_name?: string;
+            /**
+             * @description Stored on the session verbatim. Open because the key set is the client's, not this
+             *     document's — the same reason `ToolCallBody.parameters` is open.
+             */
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * @description The tool-invocation body — the surface the reasoner drives. Keys other than `tool` and
+         *     `parameters` are refused.
+         */
+        ToolCallBody: {
+            /** @description Tool name as published by the tool catalogue. */
+            tool: string;
+            /**
+             * @description The tool's own arguments. Open because the key set is the tool's, not
+             *     this document's — it is declared by the tenant's tool catalogue.
+             */
+            parameters: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description Body of the deterministic-governance replay command. */
+        TraceReplayBody: {
+            /**
+             * @description Replay against the tenant's CURRENT spec instead of the one recorded
+             *     on the trace. Omitted means `false`.
+             */
+            against_current_spec?: boolean;
+        };
         /**
-         * @description One blocked field-binding parameter-injection attempt (ADR-0106 A1).
+         * @description One blocked field-binding parameter-injection attempt.
          *     Privacy-preserving: only the SHA-256 hash + PII-mask of the offending
          *     value are present — never the raw value.
          */
@@ -1644,7 +2191,7 @@ export interface components {
             created_at: string;
         };
         /**
-         * @description One blocked regulatory-boundary hard refusal (ADR-0107).
+         * @description One blocked regulatory-boundary hard refusal.
          *     Privacy-preserving: only the SHA-256 hash + PII-mask of the input are
          *     present — never the raw input.
          */
@@ -1669,9 +2216,8 @@ export interface components {
             created_at: string;
         };
         /**
-         * @description The canonical response envelope. `data` holds the payload (shape
-         *     depends on the operation — consult the DDL + `schema.json` for the
-         *     exact per-resource shape) and `message` is an optional human
+         * @description The canonical response envelope. `data` holds the payload (its shape
+         *     depends on the operation) and `message` is an optional human
          *     summary.
          */
         SuccessEnvelope: {
@@ -1689,11 +2235,9 @@ export interface components {
             };
         };
         /**
-         * @description Tenant-class JWT payload. Spec-019 FR-A06 removed the `roles` claim;
-         *     authorization is DB-resolved fresh per request via
-         *     `permissionService.getUserRoles`, never derived from JWT claims.
-         *     See `runtime/packages/runtime-api/src/domain/auth/credential-claims.ts`
-         *     for the canonical schema.
+         * @description Tenant-class JWT payload. It carries no `roles` claim;
+         *     authorization resolves the actor's roles fresh on every request,
+         *     never from JWT claims.
          */
         JwtPayload: {
             sub: string;
@@ -1710,10 +2254,10 @@ export interface components {
             aud?: "runtime-api";
         };
         LlmCredentialMetadata: {
-            /** @description LLM service name (FK into `llm.services[]`). */
+            /** @description LLM service name; names an entry of the contract's `llm.services[]`. */
             service_name: string;
             /**
-             * @description "••••" + last 4 chars of the fingerprint. The plaintext key is NEVER returned (FR-I04).
+             * @description "••••" + last 4 chars of the fingerprint. The plaintext key is NEVER returned.
              * @example ••••WXYZ
              */
             api_key_masked: string;
@@ -1729,11 +2273,10 @@ export interface components {
         EmbeddingCredentialMetadata: {
             tenant_name: string;
             /**
-             * @description The declared `embeddings.services[].name` this credential keys to
-             *     (FR-023). Deliberately NOT a provider enum: the credential keys to a
-             *     declaration, and reporting the provider here was the response half of
-             *     the conflation that made the write unstorable. The provider is a
-             *     property of the declaration, readable from the embeddings catalog.
+             * @description The declared `embeddings.services[].name` this credential keys to.
+             *     Deliberately NOT a provider enum: the credential keys to a
+             *     declaration. The provider is a property of the declaration,
+             *     readable from the embeddings catalog.
              */
             service_name: string;
             /**
@@ -1759,11 +2302,11 @@ export interface components {
             priority: number;
             /** @description YAML declaration index. Used as priority tie-breaker. */
             position: number;
-            /** @description Per-service override; absent when null (FR-A06). */
+            /** @description Per-service override; absent when null. */
             temperature?: number;
-            /** @description Per-service override; absent when null (FR-A06). */
+            /** @description Per-service override; absent when null. */
             max_tokens?: number;
-            /** @description Per-service override of the intent-confidence floor; absent when null (FR-A06). Resolution order is flow → this → the tenant's `llm.confidence_threshold` → the single named code default. */
+            /** @description Per-service override of the intent-confidence floor; absent when null. Resolution order is flow → this → the tenant's `llm.confidence_threshold` → the platform default. */
             confidence_threshold?: number;
         };
         UserVisibleAction: {
@@ -1776,7 +2319,7 @@ export interface components {
             entity_label: string;
             description?: string;
             actions: components["schemas"]["UserVisibleAction"][];
-            /** @description FieldToolDefinition shape; see contract tool-catalog types. */
+            /** @description The entity's field definitions, as exposed in the tool catalog. */
             fields: Record<string, never>[];
             /**
              * @description MCP tool names exposed to this user for this entity. Includes
@@ -1787,7 +2330,7 @@ export interface components {
              *       - request_{entity}_{field}_transition
              *       - resolve_{entity}_{field}_transition_request
              *       - list_{entity}_{field}_pending_transition_requests
-             *     See ADR-0081 for the generation rules; structured per-trio
+             *     Structured per-trio
              *     metadata lives in UserToolCatalog.transitions.
              */
             tool_names: string[];
@@ -1796,7 +2339,7 @@ export interface components {
             from: string;
             to: string;
             /**
-             * @description Spec 015 / M4. When true, the trigger UI MUST require a reason
+             * @description When true, the trigger UI MUST require a reason
              *     textarea before dispatch. Omitted when false/absent in YAML.
              */
             requires_reason?: boolean;
@@ -1806,29 +2349,29 @@ export interface components {
             entity_name: string;
             /** @description Field declaring the transitions[] block. */
             field_name: string;
-            /** @example request_limit_requests_status_transition */
+            /** @example request_orders_status_transition */
             request_tool_name: string;
-            /** @example resolve_limit_requests_status_transition_request */
+            /** @example resolve_orders_status_transition_request */
             resolve_tool_name: string;
-            /** @example list_limit_requests_status_pending_transition_requests */
+            /** @example list_orders_status_pending_transition_requests */
             list_pending_tool_name: string;
             /**
              * @description Distinct `to` states declared reachable across all transitions of
              *     the field, in declaration order. The LLM sees this set at schema
-             *     time; the dispatch service enforces the (from, to) legality per
+             *     time; the server enforces the (from, to) legality per
              *     record.
              */
             target_states: string[];
             /**
-             * @description Per-edge projection (spec 015 / M4). Parallel to `target_states`
+             * @description Per-edge projection. Parallel to `target_states`
              *     and carries `requires_reason` so trigger UIs can mark the reason
              *     textarea required for the matching (from, to) edge. Order mirrors
              *     YAML declaration; not deduplicated.
              */
             transitions: components["schemas"]["TransitionEdge"][];
-            /** @description Optional display label for the field; used by the prompt builder. */
+            /** @description Optional display label for the field; used when building the LLM prompt. */
             field_label?: string;
-            /** @description Optional description of the field; used by the prompt builder. */
+            /** @description Optional description of the field; used when building the LLM prompt. */
             field_description?: string;
             /**
              * @description Forward-compatibility hook for a future introspect capability. V1
@@ -1838,7 +2381,7 @@ export interface components {
             inspect: boolean;
         };
         /**
-         * @description Spec 016 / M5 / ADR-0085 amendment. Per-user projection of a single
+         * @description Per-user projection of a single
          *     YAML-declared `action` the caller is authorized to dispatch.
          */
         UserVisibleActionTool: {
@@ -1849,15 +2392,15 @@ export interface components {
             verb: "create" | "read" | "update" | "delete" | "list";
             /** @description From YAML `action.description`. Optional. */
             description?: string;
-            /** @description Dispatcher-recognised intent string — `action.<name>` for native, `external.<ns>.<tool>` for external (ADR-0076). */
+            /** @description Intent string — `action.<name>` for native, `external.<ns>.<tool>` for external. */
             intent_type: string;
             /** @enum {string} */
             provenance: "native" | "external";
         };
         /**
-         * @description Spec-042 — per-tenant role declaration. Read-only metadata always
+         * @description Per-tenant role declaration. Read-only metadata always
          *     projected for every caller; editing is gated separately by the
-         *     `roles` contract-section policy (W3: surfaced via `admin_sections`).
+         *     `roles` contract-section policy (surfaced via `admin_sections`).
          */
         UserVisibleRole: {
             name: string;
@@ -1865,15 +2408,15 @@ export interface components {
             description?: string;
         };
         /**
-         * @description Spec-042 — per-tenant flow declaration projected for users with
-         *     `inspect` policy on the flow (open-by-default per ADR-0065).
+         * @description Per-tenant flow declaration projected for users with
+         *     `inspect` policy on the flow (open-by-default).
          */
         UserVisibleFlow: {
             name: string;
             description?: string;
         };
         /**
-         * @description Spec-042 — per-tenant skill declaration projected for users whose
+         * @description Per-tenant skill declaration projected for users whose
          *     role set satisfies the skill's YAML `constraints[]`.
          */
         UserVisibleSkill: {
@@ -1882,7 +2425,7 @@ export interface components {
             description?: string;
         };
         /**
-         * @description W3 — a contract section name. `UserToolCatalog.admin_sections` is the
+         * @description A contract section name. `UserToolCatalog.admin_sections` is the
          *     subset the caller's roles can `update` (drives admin mutation pages).
          * @enum {string}
          */
@@ -1896,36 +2439,49 @@ export interface components {
              * @description Structured metadata for every state-machine transition trio
              *     visible to this user. One entry per (entity, field) with
              *     non-empty transitions[] for which user_roles ∩ R(entity, field)
-             *     ≠ ∅. See ADR-0081.
+             *     ≠ ∅.
              */
             transitions: components["schemas"]["UserVisibleTransitionTool"][];
             /**
-             * @description Spec 016 / M5 / ADR-0085 amendment. Per-user projection of
-             *     YAML-declared `actions[]` the caller is authorized to dispatch.
-             *     One entry per action whose `(entity, verb)` resolves to
-             *     `kind: 'action'` under the action-surface-resolver decision
-             *     logic for the caller's capabilities. Hidden/entity-fallback
-             *     decisions are NOT projected. Optional — omitted entirely when
-             *     zero entries.
+             * @description THE TOOL SURFACE: every EXPOSED action this user may dispatch, each registered as
+             *     a tool alias. An action appears here
+             *     when `expose_as_mcp_tool: true` AND the underlying `(entity, verb)` is
+             *     granted; there is no per-pair dedup, because an alias is registered
+             *     for every exposed action and a pair may legitimately carry two.
+             *
+             *     NOT the prompt's action list and NOT the dispatchable list: see
+             *     `dispatchable_actions`, which carries every GRANTED action and is what a UI
+             *     offering action buttons must read.
              */
             actions?: components["schemas"]["UserVisibleActionTool"][];
             /**
-             * @description Spec-042 — declared roles in the tenant contract (read-only
-             *     metadata always emitted, even when empty).
+             * @description EVERY GRANTED action, exposure irrelevant: what this user may DISPATCH
+             *     by name through `POST /runtime/actions/:name`, whether or not an MCP tool
+             *     carries it.
+             *
+             *     The sibling of `actions[]`, and the reason that field can be the tool surface
+             *     without losing anything. A UI offering action buttons must read THIS one: the
+             *     bare `/runtime/records` surface enforces named-action routing, so a verb
+             *     carrying a named action answers `action_required` there — a missing button
+             *     would leave the verb with no path at all.
+             *
+             *     Optional — omitted entirely when zero entries.
              */
-            roles: components["schemas"]["UserVisibleRole"][];
+            dispatchable_actions?: components["schemas"]["UserVisibleActionTool"][];
             /**
-             * @description Spec-042 — flows the user can `inspect` (ADR-0065
-             *     open-by-default).
+             * @description Declared roles in the tenant contract (read-only
+             *     metadata always emitted, even when empty).
              */
+            roles: components["schemas"]["UserVisibleRole"][];
+            /** @description Flows the user can `inspect` (open-by-default). */
             flows: components["schemas"]["UserVisibleFlow"][];
             /**
-             * @description Spec-042 — skills whose YAML `constraints[]` evaluate true for
+             * @description Skills whose YAML `constraints[]` evaluate true for
              *     the user.
              */
             skills: components["schemas"]["UserVisibleSkill"][];
             /**
-             * @description W3 (ADR-0102 §3 closure) — contract sections the user can `update`,
+             * @description Contract sections the user can `update`,
              *     derived from `authorization.spec.{section}` policies. The dashboard
              *     derives admin mutation pages (roles/skills/flows/authorization+
              *     policies/state-machines/settings) and the admin-tier pages
@@ -1939,69 +2495,275 @@ export interface components {
         } & {
             [key: string]: unknown;
         };
-        /**
-         * @description Opaque 64-hex digest of a party's address within its channel's address
-         *     namespace (QI-001). NOT an address — the runtime never names a phone
-         *     number, an email or a handle.
-         */
-        ChannelPartyRef: string;
-        /** @description Content digest — metadata-only handle, never the body (R12). */
-        ChannelContentRef: string;
-        /** @description Tenant-declared channel name (the `channels:` contract section). */
-        ChannelName: string;
-        /** @enum {string} */
-        ChannelDeliveryMode: "freeform" | "template" | "deferred";
-        /**
-         * @description Who attests the send outcome — the runtime itself, or the channel
-         *     provider (the transport descriptor declares which is admissible).
-         * @enum {string}
-         */
-        ChannelAttestedBy: "runtime" | "channel_provider";
-        /**
-         * @description Strict by construction: `party_ref` is the ONLY accepted key. The
-         *     strictness IS the QI-003 claim rejection — any role/privilege key
-         *     alongside it fails validation (422 `MINT_CLAIM_REJECTED`) before the
-         *     mint. The channel comes from the credential, never from here.
-         */
-        ChannelMintRequest: {
-            party_ref: components["schemas"]["ChannelPartyRef"];
-        };
-        ChannelPartyToken: {
+        /** @description The fields of a resolution. At least one is required — a body carrying none is refused *"patch body requires at least one mutable field"*. `status` is the resolution: the caller's approver authority is checked, the transition's rules are re-checked at commit, and a linked flow run is resumed in the same transaction; a body with only `decision_notes` annotates the request and changes no state. `resolved_by` and `resolved_at` are NOT settable — the approver is the authenticated caller and the time is when the resolution commits — and a body carrying either is refused rather than silently ignored. */
+        TransitionRequestResolveBody: {
             /**
-             * @description Short-TTL anonymous party token (`token_class: party`) bound to
-             *     `(channel, party_ref)`. Carries no role and grants no authority.
+             * @description Only the two a caller may write. `pending` is an outcome, not a request: the `?status=` filter admits it because listing pending requests is a different question.
+             * @enum {string}
              */
-            token: string;
-            /** Format: date-time */
-            expires_at: string;
-        };
-        ChannelDirectiveTemplateRef: {
-            id: string;
-            version: number;
-        };
-        ChannelDirectiveCorrelation: {
-            session_key: string;
-            turn_seq: number;
+            status?: "approved" | "rejected";
+            decision_notes?: string | null;
         };
         /**
-         * @description The claimed directive plus its resolved content. `fetch = claim`, so
-         *     receiving this body means the lease is now held by the caller's `jti`.
+         * @description One of THREE statuses. There is no `expired` status: a transition request has no
+         *     deadline.
+         * @enum {string}
          */
-        ChannelDirectiveContent: {
+        TransitionRequestStatus: "pending" | "approved" | "rejected";
+        /** @description One record-field state machine. Every field is always present. */
+        StateMachineInstance: {
             /** Format: uuid */
             id: string;
-            channel_name: components["schemas"]["ChannelName"];
-            recipient_ref: components["schemas"]["ChannelPartyRef"];
-            content_ref: components["schemas"]["ChannelContentRef"];
-            delivery_mode: components["schemas"]["ChannelDeliveryMode"];
-            template?: components["schemas"]["ChannelDirectiveTemplateRef"];
-            correlation: components["schemas"]["ChannelDirectiveCorrelation"];
+            entity_name: string;
+            record_id: number;
+            field_name: string;
+            current_state: string;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at: string;
+        };
+        /** @description One recorded transition. `actor` is always present; the other optional fields may be absent. */
+        StateMachineEvent: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            instance_id: string;
+            from_state: string;
+            to_state: string;
+            actor: string;
+            /** @description ABSENT when there is no value — never `null`. */
+            actor_role?: string;
+            payload?: {
+                [key: string]: unknown;
+            };
+            /** @description Currently always absent. */
+            rule_evaluations?: {
+                [key: string]: unknown;
+            };
+            /** Format: date-time */
+            created_at: string;
+        };
+        /**
+         * @description A requested transition awaiting a decision. Note `transition_request_id`, not `id`, and
+         *     `target_state` for what the create body calls `requested_transition`.
+         */
+        TransitionRequest: {
+            /** Format: uuid */
+            transition_request_id: string;
+            /** Format: uuid */
+            instance_id: string;
+            entity_name: string;
+            record_id: number;
+            current_state: string;
+            target_state: string;
+            field_name: string;
+            /** @description Always present; `[]` when there are none. */
+            required_roles: string[];
+            reason?: string;
+            status: components["schemas"]["TransitionRequestStatus"];
+            resolved_by?: string;
+            /** Format: date-time */
+            resolved_at?: string;
+            decision_notes?: string;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at: string;
+        };
+        StateMachineInstanceList: {
+            count: number;
+            instances: components["schemas"]["StateMachineInstance"][];
+        };
+        StateMachineEventList: {
+            count: number;
+            events: components["schemas"]["StateMachineEvent"][];
+        };
+        TransitionRequestList: {
+            count: number;
+            transition_requests: components["schemas"]["TransitionRequest"][];
+        };
+        /**
+         * @description The flow-event vocabulary, shared by `listFlowEvents`'s `event_type` filter
+         *     and `FlowEvent.event_type`.
+         * @enum {string}
+         */
+        FlowEventKind: "FlowStarted" | "FlowStepCompleted" | "FlowStepFailed" | "FlowStepSkipped" | "FlowStepAlreadyCompleted" | "FlowPaused" | "FlowResumed" | "FlowCompleted" | "FlowFailed" | "FlowConstraintViolated" | "FlowConstraintUnverifiable";
+        /**
+         * @description One flow run. There is no `started_at` and no `steps` collection: the start time is
+         *     `created_at`, and per-step history lives in the run's flow events (`FlowEvent`).
+         */
+        FlowInstance: {
+            /** Format: uuid */
+            id: string;
+            tenant_name: string;
+            flow_name: string;
+            session_id: string;
+            /**
+             * @description Who started the run. `'anonymous'` for every channel party — the pair that
+             *     OWNS the run is `party_ref` + `channel_name`, never this field.
+             */
+            actor: string;
+            /** @description The owning party pair; `null` for a non-party actor. */
+            party_ref: string | null;
+            /** @description Set exactly when `party_ref` is. */
+            channel_name: string | null;
+            /** @enum {string} */
+            status: "running" | "paused" | "resuming" | "completed" | "failed";
+            /** @description ABSENT (not `null`) when there is none. */
+            trigger_data?: {
+                [key: string]: unknown;
+            };
+            /** @description ABSENT (not `null`) when there is none — a run in flight has none. */
+            final_state?: {
+                [key: string]: unknown;
+            };
+            error: string | null;
+            /**
+             * Format: date-time
+             * @description When the run started.
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description Last update to the run. For a TERMINAL status (`completed` / `failed`) that is
+             *     when the run ended, so `updated_at - created_at` is its duration. It is NOT a
+             *     completion timestamp for a run still in flight — check `status` first. For an
+             *     exact figure prefer the `FlowCompleted` / `FlowFailed` event's `duration_ms`,
+             *     which the engine measures rather than infers.
+             */
+            updated_at: string;
+        };
+        /**
+         * @description One appended flow lifecycle event. This is where per-step history lives: a step
+         *     appears as an event whose `step_name` is set and whose `event_type` is one of
+         *     the `FlowStep*` kinds. Returned in CHAIN order (`seq`), not `created_at` —
+         *     events appended together share a timestamp, so only `seq` totally
+         *     orders them.
+         */
+        FlowEvent: {
+            /** Format: uuid */
+            id: string;
+            tenant_name: string;
+            /** Format: uuid */
+            instance_id: string;
+            event_type: components["schemas"]["FlowEventKind"];
+            /** @description The step this event is about; `null` on a run-level kind (`FlowStarted`, …). */
+            step_name: string | null;
+            output_key: string | null;
+            /** @description ABSENT (not `null`) when there is no payload. */
+            payload?: {
+                [key: string]: unknown;
+            };
+            /** @description Measured elapsed time for the step, or for the whole run on a terminal event. */
+            duration_ms: number | null;
+            /** @description Which run of the instance appended this event (a resume increments it). */
+            attempt: number;
+            /** Format: date-time */
+            created_at: string;
+        };
+        /**
+         * @description A suspended flow's resumption point. The `id` is the capability token an
+         *     external system presents to resolve the run.
+         */
+        FlowCallback: {
+            /** Format: uuid */
+            id: string;
+            tenant_name: string;
+            flow_name: string;
+            session_id: string;
+            event_name: string;
+            step_name: string;
+            /** @enum {string} */
+            status: "pending" | "completed" | "timed_out" | "failed";
+            /** @description The saved state the run resumes from. Always present — `{}` when empty. */
+            flow_state: {
+                [key: string]: unknown;
+            };
+            /** @description What the resolver supplied; `null` until the callback is resolved. */
+            callback_payload: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: date-time */
+            timeout_at: string | null;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            completed_at: string | null;
+        };
+        /**
+         * @description Opaque 64-hex digest of a party's address within its channel's address
+         *     namespace. NOT an address — the runtime never names a phone
+         *     number, an email or a handle.
+         */
+        ChannelPartyRef: string;
+        /** @description Content digest — metadata-only handle, never the body. */
+        ChannelContentRef: string;
+        /**
+         * @description A channel name as returned in responses: the kebab class and NOTHING ELSE.
+         *     Every stored channel name is at most 64 characters, but that width is not published on this output form.
+         *     IT DOES NOT STATE THE RESERVED-NAME REFUSAL. The refusal is an INPUT rule, applied where a name is parsed from a request; `NonReservedChannelName` carries it, at the sites that parse.
+         */
+        ChannelName: string;
+        /**
+         * @description A channel name as accepted in requests: the kebab class of `ChannelName`, at most 64 characters, and not one of the reserved words.
+         *     THIS IS AN INPUT RULE, published only where a request carries a channel name. It is deliberately absent from response bodies, which carry what is stored.
+         *     EVERY NAME THIS REFUSES IS ONE NO CHANNEL CAN HAVE: the contract API refuses the same names when a channel is written.
+         */
+        NonReservedChannelName: components["schemas"]["ChannelName"] & unknown & unknown;
+        /** @enum {string} */
+        ChannelDeliveryMode: "freeform" | "template" | "deferred";
+        /**
+         * @description Who attests the send outcome — the runtime itself, or the channel
+         *     provider (the transport descriptor declares which is admissible).
+         * @enum {string}
+         */
+        ChannelAttestedBy: "runtime" | "channel_provider";
+        /**
+         * @description Strict by construction: `party_ref` is the ONLY accepted key. The
+         *     Strict by construction: `party_ref` is the ONLY accepted key. Any
+         *     role/privilege key alongside it fails validation (422 `MINT_CLAIM_REJECTED`) before the
+         *     mint. The channel comes from the credential, never from here.
+         */
+        ChannelMintRequest: {
+            party_ref: components["schemas"]["ChannelPartyRef"];
+        };
+        ChannelPartyToken: {
+            /**
+             * @description Short-TTL anonymous party token (`token_class: party`) bound to
+             *     `(channel, party_ref)`. Carries no role and grants no authority.
+             */
+            token: string;
+            /** Format: date-time */
+            expires_at: string;
+        };
+        ChannelDirectiveTemplateRef: {
+            id: string;
+            version: number;
+        };
+        ChannelDirectiveCorrelation: {
+            session_key: string;
+            turn_seq: number;
+        };
+        /**
+         * @description The claimed directive plus its resolved content. `fetch = claim`, so
+         *     receiving this body means the lease is now held by the caller's `jti`.
+         */
+        ChannelDirectiveContent: {
+            /** Format: uuid */
+            id: string;
+            channel_name: components["schemas"]["ChannelName"];
+            recipient_ref: components["schemas"]["ChannelPartyRef"];
+            content_ref: components["schemas"]["ChannelContentRef"];
+            delivery_mode: components["schemas"]["ChannelDeliveryMode"];
+            template?: components["schemas"]["ChannelDirectiveTemplateRef"];
+            correlation: components["schemas"]["ChannelDirectiveCorrelation"];
             /** Format: date-time */
             deadline_at?: string;
             /**
              * @description The resolved turn body, returned ONLY here — the directive itself
-             *     (and every audit row) carries `content_ref` and never the content
-             *     (R12 / QI-004). Resolved by the directive's turn correlation as an
+             *     (and every audit entry) carries `content_ref` and never the content.
+             *     Resolved by the directive's turn correlation as an
              *     authorized, audited read.
              */
             content: unknown;
@@ -2010,8 +2772,8 @@ export interface components {
             /** @enum {string} */
             status: "accepted" | "failed" | "deferred";
             /**
-             * @description Provider-supplied opaque id. MUST already be hashed by the adapter
-             *     (FR-E03) — an E.164- or email-shaped value is refused (QI-001).
+             * @description Provider-supplied opaque id. MUST already be hashed by the adapter —
+             *     an E.164- or email-shaped value is refused.
              */
             provider_message_id?: string;
             attested_by: components["schemas"]["ChannelAttestedBy"];
@@ -2090,6 +2852,24 @@ export interface components {
                 "application/json": components["schemas"]["ErrorResponse"];
             };
         };
+        /** @description A precondition on the tenant's configuration is unmet — the resolved LLM service has no credential (`NO_CREDENTIAL_CONFIGURED`) or one that cannot be read (`CREDENTIAL_UNREADABLE`). Not an authorization failure: the actor may use the service. */
+        PreconditionFailed: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description A declared conversational ceiling is reached: `CONVERSATION_TURN_LIMIT` (the per-role turn cap) or `CONVERSATION_TOKEN_LIMIT` (the per-role token ceiling — also what a fail-CLOSED metering fault answers for an anonymous party). Governed limits, not infrastructure throttling: the code says which ceiling, and the actor's own contract set it. Both answer 429. */
+        TooManyRequests: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
         /** @description Resource state conflict */
         Conflict: {
             headers: {
@@ -2100,7 +2880,7 @@ export interface components {
             };
         };
         /**
-         * @description ADR-0127 US2 — the verb is governed by ≥1 named action and must be
+         * @description The verb is governed by ≥1 named action and must be
          *     dispatched via `POST /runtime/actions/{name}`; the bare records surface
          *     rejects it. `error.code='action_required'`; `error.candidate_actions[]`
          *     lists the eligible action names.
@@ -2118,7 +2898,7 @@ export interface components {
             };
         };
         /**
-         * @description ADR-0127 — the write floor blocked the mutation: `error.code` is
+         * @description The write was blocked: `error.code` is
          *     `phase_not_allowed` (action not allowed in the record's current process
          *     phase) or `precondition_failed` (a declared precondition evaluated false
          *     against the real record set).
@@ -2132,7 +2912,7 @@ export interface components {
             };
         };
         /**
-         * @description ADR-0127 US3 — a `confirm` guard (an entity check or a transition edge)
+         * @description A `confirm` guard (an entity check or a transition edge)
          *     paused this write pending human consent; the write is not performed.
          *     Re-submit the IDENTICAL write with the returned token in the
          *     `X-Zarel-Confirmation-Token` header before `expires_at`.
@@ -2205,14 +2985,14 @@ export interface components {
         };
     };
     parameters: {
-        /** @description Canonical natural-key identifier (ADR-0077 P4) */
+        /** @description Canonical natural-key identifier */
         NamePath: string;
         EntityNamePath: string;
-        /** @description Egress directive id (ADR-0133 §B.4) */
+        /** @description Egress directive id */
         ChannelDirectiveIdPath: string;
         RequestId: string;
         /**
-         * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+         * @description The self-confirmation retry token from a prior `409
          *     confirmation_required` response. Re-submit the IDENTICAL write carrying
          *     this header to proceed. The token is bound to the exact write
          *     (tenant/actor/contract-version/action/entity/verb/record/params) and
@@ -2231,18 +3011,56 @@ export interface components {
          */
         Locale: "en" | "es";
     };
-    requestBodies: {
-        JsonObject: {
-            content: {
-                "application/json": Record<string, never>;
-            };
-        };
-    };
+    requestBodies: never;
     headers: never;
     pathItems: never;
 }
 export type $defs = Record<string, never>;
 export interface operations {
+    getBranding: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Locale for the display name. Published inline rather than as the
+                 *     shared `Locale` parameter because it behaves differently from it.
+                 *
+                 *     An unsupported single value falls back to the canonical locale
+                 *     (`en`) instead of the 400 the shared parameter promises — this
+                 *     selects a RENDERING, and a rendering has a default where a filter
+                 *     has none. A REPEATED `?locale=a&locale=b` is a 400.
+                 */
+                locale?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The tenant's branding. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description The tenant label for the locale, falling back to the tenant name. */
+                        displayName: string;
+                        /**
+                         * @description An `https://` URL or a root-relative path. Re-validated at
+                         *     this boundary and answered as `null` when it fails, so a
+                         *     malformed stored value never reaches a consumer.
+                         */
+                        logoUrl: string | null;
+                        /** @description A `#rrggbb` colour, or `null` when the stored value is not one. */
+                        accentColor: string | null;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     listLlmServices: {
         parameters: {
             query: {
@@ -2360,11 +3178,17 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CredentialWriteBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
             400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
         };
     };
     deleteLlmCredential: {
@@ -2408,7 +3232,7 @@ export interface operations {
             path: {
                 /**
                  * @description The DECLARED embedding-service name from `embeddings.services[]`
-                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     — not the provider. A provider is not an identity: two
                  *     services may share one, and the credential keys to a declaration that
                  *     exists. The provider is resolved from that declaration server-side.
                  */
@@ -2429,7 +3253,7 @@ export interface operations {
             path: {
                 /**
                  * @description The DECLARED embedding-service name from `embeddings.services[]`
-                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     — not the provider. A provider is not an identity: two
                  *     services may share one, and the credential keys to a declaration that
                  *     exists. The provider is resolved from that declaration server-side.
                  */
@@ -2437,11 +3261,17 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CredentialWriteBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
             400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
         };
     };
     deleteEmbeddingCredential: {
@@ -2451,7 +3281,7 @@ export interface operations {
             path: {
                 /**
                  * @description The DECLARED embedding-service name from `embeddings.services[]`
-                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     — not the provider. A provider is not an identity: two
                  *     services may share one, and the credential keys to a declaration that
                  *     exists. The provider is resolved from that declaration server-side.
                  */
@@ -2474,10 +3304,36 @@ export interface operations {
     listRuntimeRecords: {
         parameters: {
             query?: {
+                /** @description Page size, capped at 200. `0` is an empty page, not an error. */
                 limit?: number;
                 offset?: number;
-                sort_by?: string;
-                sort_dir?: "asc" | "desc";
+                /**
+                 * @description Per-field filters, e.g. `filters[status]=open`. A value is one of three spellings:
+                 *
+                 *     - a bare scalar — shorthand for `{"op":"eq","value":<scalar>}`;
+                 *     - a JSON-encoded `{"op":…,"value":…}` — one operator;
+                 *     - a JSON-encoded array of those — an AND of operators within the field.
+                 *
+                 *     `op` is one of `eq`, `neq`, `contains`, `startsWith`, `endsWith`, `gt`, `gte`, `lt`,
+                 *     `lte`, `between`, `in`, `not_in`, `before`, `after`, `is_empty`, `is_not_empty`; an
+                 *     unknown one is a 400 `invalid_filter_operator`. Operator-versus-field-type validation
+                 *     is NOT applied server-side.
+                 *
+                 *     The bracket-expanded spelling of the last two — `filters[f][op]=gt&filters[f][value]=3`
+                 *     — is accepted and equivalent, which is why the value schema is unconstrained: all three
+                 *     documented spellings are strings, and that one is not.
+                 */
+                filters?: {
+                    [key: string]: unknown;
+                };
+                /**
+                 * @description JSON-encoded `[{field, dir}]`, e.g. `sort=[{"field":"created_at","dir":"desc"}]`.
+                 *     `dir` is `asc` or `desc`; an unknown field or an unknown direction is a 400.
+                 *     Absent (or `[]`), the list is ordered by the entity's declared `default_sort`, and by
+                 *     `created_at` newest first when it declares none. A `sort` sent here replaces the
+                 *     declared one outright; the two are never merged.
+                 */
+                sort?: string;
             };
             header?: never;
             path: {
@@ -2488,6 +3344,7 @@ export interface operations {
         requestBody?: never;
         responses: {
             200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["BadRequest"];
         };
     };
     createRuntimeRecord: {
@@ -2495,7 +3352,7 @@ export interface operations {
             query?: never;
             header?: {
                 /**
-                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 * @description The self-confirmation retry token from a prior `409
                  *     confirmation_required` response. Re-submit the IDENTICAL write carrying
                  *     this header to proceed. The token is bound to the exact write
                  *     (tenant/actor/contract-version/action/entity/verb/record/params) and
@@ -2508,7 +3365,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RuntimeRecordCreateBody"];
+            };
+        };
         responses: {
             201: components["responses"]["OkEnvelope"];
             400: components["responses"]["ActionRequired"];
@@ -2537,7 +3398,7 @@ export interface operations {
             query?: never;
             header?: {
                 /**
-                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 * @description The self-confirmation retry token from a prior `409
                  *     confirmation_required` response. Re-submit the IDENTICAL write carrying
                  *     this header to proceed. The token is bound to the exact write
                  *     (tenant/actor/contract-version/action/entity/verb/record/params) and
@@ -2564,7 +3425,7 @@ export interface operations {
             query?: never;
             header?: {
                 /**
-                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 * @description The self-confirmation retry token from a prior `409
                  *     confirmation_required` response. Re-submit the IDENTICAL write carrying
                  *     this header to proceed. The token is bound to the exact write
                  *     (tenant/actor/contract-version/action/entity/verb/record/params) and
@@ -2578,7 +3439,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RuntimeRecordPatchBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
             400: components["responses"]["ActionRequired"];
@@ -2610,7 +3475,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The tenant's state-machine instances. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["StateMachineInstanceList"];
+                    };
+                };
+            };
         };
     };
     getStateMachineInstance: {
@@ -2624,7 +3499,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description One state-machine instance. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["StateMachineInstance"];
+                    };
+                };
+            };
             404: components["responses"]["NotFound"];
         };
     };
@@ -2640,7 +3525,18 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The transition log. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["StateMachineEventList"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
         };
     };
     getStateMachineEvent: {
@@ -2654,15 +3550,25 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description One recorded transition. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["StateMachineEvent"];
+                    };
+                };
+            };
             404: components["responses"]["NotFound"];
         };
     };
     listTransitionRequests: {
         parameters: {
             query?: {
-                status?: "pending" | "approved" | "rejected";
-                role?: string;
+                status?: components["schemas"]["TransitionRequestStatus"];
+                roles?: string[];
             };
             header?: never;
             path?: never;
@@ -2670,7 +3576,18 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The transition requests visible to the caller. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["TransitionRequestList"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
         };
     };
     createTransitionRequest: {
@@ -2680,9 +3597,84 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TransitionRequestCreateBody"];
+            };
+        };
         responses: {
-            201: components["responses"]["OkEnvelope"];
+            /** @description The created request. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["TransitionRequest"];
+                    };
+                };
+            };
+            /**
+             * @description The body is malformed, it carries a server-owned key (`required_roles`, `instance_id`, `flow_instance_id` — see the body schema), or the contract declares no transition `current_state` → `requested_transition` for `entity_name`.`field_name`. A rule-passing edge that declares `requires_reason` and got no `reason` is also a 400, under its own `error.code` of `reason_required`.
+             *     Also 400 when the rule-passing edges' approver set is empty once the `owner` pseudo-role is stripped: `owner` is a per-record ownership gate, never an assignable authority someone else holds to approve on the actor's behalf. An owner-only edge is performed by its owner, not requested; a request for it could never be resolved.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The caller may not RAISE a request for this record's field (`error.code` = `transition_request_not_permitted`).
+             *     The authority required is `update` on the field, for that record: the authority to ask for a transition IS the authority to update the field. It is deliberately NOT the edge's `allowed_roles`: those are the APPROVER set, and an actor holding them would have no reason to request.
+             *     ONE opaque refusal whichever clause failed — no grant, an owner-scoped grant on another actor's record, a grant whose field list does not open this field, or no such record. Those are four different facts about a record the caller may not be able to read, so the response distinguishes none of them.
+             *     Answered BEFORE any per-record read, so an unauthorized caller learns nothing from the 409s and 422 below, each of which discriminates on the record.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The entity/field declares no state machine at all, the record is in a state other than the `current_state` the body asserts — re-read the record and retry — or the edge's rules could not be evaluated at all.
+             *     A record whose field has never ENTERED its state machine is not a refusal: the machine is started at the contract's `initial` state, so a first transition is possible here too. When the body's state the machine started at, because "re-read and retry" is unactionable for a field whose only readable value is the one just sent.
+             *     That last cause is deliberately not separable from a missing record, and — like the 422 — is reachable only when the matching edges disagree about who may approve, which is the one shape whose answer needs the record. The rules are then evaluated under the caller's own `read` grants, the same decision `GET /runtime/records/{entity}/{id}` makes, so it is the answer when the record is gone, when the caller holds no grant on its entity or on one the rules reference, and when the grant is owner-scoped and the record is someone else's. A status telling those apart would answer an existence question about a READ this operation never authorized — its authority check establishes only that the caller may UPDATE the field. It is a 409 rather than a 500 because every one of those causes is deterministic and 500 is a retryable status for the first-party SDK.
+             */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /**
+             * @description The contract declares edges for `current_state` → `requested_transition` that DISAGREE about who may approve, and none of their rules pass for this record — so there is no approver set to write (`error.code` = `business_rules_failed`).
+             *     Reachable only for that shape. The request's `required_roles` is the union over the edges whose rules pass, and when every matching edge names the same approvers that union is decided by the contract alone, so no rule is evaluated, no record is read, and a request is created whichever way the rules would have gone.
+             *     The refusal names the edge and NOT the rule that failed, unlike the same code on `PATCH .../transition-requests/{id}` — that surface checks the caller's roles against the request's `required_roles` first. This one never intersects the caller against an approver set; it has an `update` authority check, which is a different question, so the failing rule's operands stay withheld.
+             */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The contract could not be READ at all — the rule gate faulted — so the approver set for this edge is underivable, and the request is REFUSED rather than created: the server does not fall back to the body's own `required_roles`, which would fail open. A server fault, and retrying it is right; the deterministic "could not be evaluated" cases are the 409 above. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
         };
     };
     getTransitionRequest: {
@@ -2696,7 +3688,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description One transition request. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["TransitionRequest"];
+                    };
+                };
+            };
             404: components["responses"]["NotFound"];
         };
     };
@@ -2709,9 +3711,23 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TransitionRequestResolveBody"];
+            };
+        };
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The resolved request. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["TransitionRequest"];
+                    };
+                };
+            };
         };
     };
     dispatchAction: {
@@ -2719,7 +3735,7 @@ export interface operations {
             query?: never;
             header?: {
                 /**
-                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 * @description The self-confirmation retry token from a prior `409
                  *     confirmation_required` response. Re-submit the IDENTICAL write carrying
                  *     this header to proceed. The token is bound to the exact write
                  *     (tenant/actor/contract-version/action/entity/verb/record/params) and
@@ -2735,16 +3751,7 @@ export interface operations {
         };
         requestBody?: {
             content: {
-                "application/json": {
-                    /** @description Required for read/update/delete verbs; null/omitted for create/list (entity-level). */
-                    record_id?: number | string | null;
-                    /** @description Forwarded to the underlying entity intent. */
-                    payload?: {
-                        [key: string]: unknown;
-                    };
-                    /** @description V1 wire-format pass-through; server-side dedup deferred. */
-                    idempotency_key?: string;
-                };
+                "application/json": components["schemas"]["ActionDispatchBody"];
             };
         };
         responses: {
@@ -2760,7 +3767,7 @@ export interface operations {
                         data: {
                             [key: string]: unknown;
                         } | null;
-                        /** @description ADR-0085 telemetry tag — action name as resolved. */
+                        /** @description Telemetry tag — action name as resolved. */
                         resolved_via_action: string;
                     };
                 };
@@ -2808,7 +3815,18 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The runs visible to the caller. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowInstance"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
         };
     };
     getFlowInstance: {
@@ -2822,7 +3840,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description One flow run. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowInstance"];
+                    };
+                };
+            };
             404: components["responses"]["NotFound"];
         };
     };
@@ -2832,7 +3860,7 @@ export interface operations {
                 /** @description Only events belonging to this flow instance. */
                 instance_id?: string;
                 /** @description Only events of this kind. An unrecognised kind is refused `400` rather than silently matching nothing. */
-                event_type?: "FlowStarted" | "FlowStepCompleted" | "FlowStepFailed" | "FlowStepSkipped" | "FlowStepAlreadyCompleted" | "FlowPaused" | "FlowResumed" | "FlowCompleted" | "FlowFailed" | "FlowConstraintViolated" | "FlowConstraintUnverifiable";
+                event_type?: components["schemas"]["FlowEventKind"];
             };
             header?: never;
             path?: never;
@@ -2840,7 +3868,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The lifecycle log visible to the caller, in chain (`seq`) order. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowEvent"][];
+                    };
+                };
+            };
             400: components["responses"]["BadRequest"];
         };
     };
@@ -2855,7 +3893,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description One flow lifecycle event. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowEvent"];
+                    };
+                };
+            };
             404: components["responses"]["NotFound"];
         };
     };
@@ -2868,7 +3916,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description The tenant's flow callbacks. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowCallback"][];
+                    };
+                };
+            };
         };
     };
     getFlowCallback: {
@@ -2882,7 +3940,17 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            200: components["responses"]["OkEnvelope"];
+            /** @description One flow callback. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowCallback"];
+                    };
+                };
+            };
             404: components["responses"]["NotFound"];
         };
     };
@@ -2895,20 +3963,26 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["FlowCallbackResolveBody"];
+            };
+        };
         responses: {
-            /** @description Flat callback-resolution ack (success + optional message). */
+            /** @description The resolved callback. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
-                        success: boolean;
-                        message?: string;
+                    "application/json": components["schemas"]["SuccessEnvelope"] & {
+                        data: components["schemas"]["FlowCallback"];
                     };
                 };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
         };
     };
     listEventSubscriptions: {
@@ -2930,7 +4004,11 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EventSubscriptionCreateBody"];
+            };
+        };
         responses: {
             201: components["responses"]["OkEnvelope"];
         };
@@ -2973,7 +4051,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EventSubscriptionPatchBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
         };
@@ -3008,11 +4090,12 @@ export interface operations {
     listConversationSessions: {
         parameters: {
             query?: {
-                /** @description Declared channel name (tenant `channels:` section, ADR-0133) */
-                channel_name?: string;
+                /** @description Declared channel name (tenant `channels:` section). A malformed value is a 400; it is not DISCARDED, which would answer 200 with every session the actor owns on every channel — a filter the caller asked for and did not get. */
+                channel_name?: components["schemas"]["NonReservedChannelName"];
                 status?: "active" | "expired" | "cleared";
                 from?: string;
                 to?: string;
+                /** @description Page size, clamped to 100. `0` is an empty page, not an error. */
                 limit?: number;
                 offset?: number;
             };
@@ -3023,6 +4106,7 @@ export interface operations {
         requestBody?: never;
         responses: {
             200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["BadRequest"];
         };
     };
     createConversationSession: {
@@ -3032,10 +4116,15 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ConversationSessionCreateBody"];
+            };
+        };
         responses: {
             201: components["responses"]["OkEnvelope"];
             400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
         };
@@ -3152,7 +4241,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["ChannelBindingVerifyBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
             /** @description Missing the system action — `error.code='verify_channel_binding_required'` */
@@ -3185,10 +4278,14 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RoleAssignmentCreateBody"];
+            };
+        };
         responses: {
             201: components["responses"]["OkEnvelope"];
-            /** @description Owner-marked role — `error.code='owner_role_protected'` (ADR-0102 S4) */
+            /** @description Owner-marked role — `error.code='owner_role_protected'` */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -3221,7 +4318,7 @@ export interface operations {
         requestBody?: never;
         responses: {
             200: components["responses"]["OkEnvelope"];
-            /** @description Owner-marked role — `error.code='owner_role_protected'` (ADR-0102 S4) */
+            /** @description Owner-marked role — `error.code='owner_role_protected'` */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -3239,12 +4336,16 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ConversationSendBody"];
+            };
+        };
         responses: {
             /**
              * @description Cognitive-agent reply — a **flat** body (`success` + `message` +
              *     optional intent/clarification fields), NOT envelope-wrapped. The SDK
-             *     returns it whole (codegen-unwrap: no-unwrap).
+             *     returns it whole.
              */
             200: {
                 headers: {
@@ -3264,7 +4365,11 @@ export interface operations {
                     };
                 };
             };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            412: components["responses"]["PreconditionFailed"];
+            429: components["responses"]["TooManyRequests"];
         };
     };
     runtimeChannelsMint: {
@@ -3291,7 +4396,7 @@ export interface operations {
             };
             /**
              * @description `MINT_CLAIM_REJECTED` — the body carried a role/privilege claim, or
-             *     any key other than `party_ref`. Refused before the mint (QI-003).
+             *     any key other than `party_ref`. Refused before the mint.
              */
             422: {
                 headers: {
@@ -3340,7 +4445,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                /** @description Egress directive id (ADR-0133 §B.4) */
+                /** @description Egress directive id */
                 id: components["parameters"]["ChannelDirectiveIdPath"];
             };
             cookie?: never;
@@ -3359,10 +4464,7 @@ export interface operations {
                     "application/json": components["schemas"]["ChannelDirectiveContent"];
                 };
             };
-            /**
-             * @description The directive belongs to another channel — refused, never readable
-             *     (QI-006).
-             */
+            /** @description The directive belongs to another channel — refused, never readable. */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -3391,7 +4493,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                /** @description Egress directive id (ADR-0133 §B.4) */
+                /** @description Egress directive id */
                 id: components["parameters"]["ChannelDirectiveIdPath"];
             };
             cookie?: never;
@@ -3415,7 +4517,7 @@ export interface operations {
                 };
             };
             400: components["responses"]["BadRequest"];
-            /** @description The directive belongs to another channel — refused (QI-006). */
+            /** @description The directive belongs to another channel — refused. */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -3484,8 +4586,8 @@ export interface operations {
                         admin_sections: string[];
                         system_actions: string[];
                         /**
-                         * @description ADR-0102 S5b-a (FR-012): bounds carried by the actor's
-                         *     matched CONDITIONED system grants (e.g. the Cat-2
+                         * @description Bounds carried by the actor's
+                         *     matched CONDITIONED system grants (e.g. the
                          *     provider allow-lists on `manage_credentials`). Present
                          *     only when at least one matched grant is bounded.
                          */
@@ -3496,25 +4598,25 @@ export interface operations {
                             entity: string;
                             actions: string[];
                             /**
-                             * @description The scope the write floor will enforce for each reported action.
-                             *     `full` reaches every row; `owner` reaches only rows the caller
+                             * @description The scope the server will enforce for each reported action.
+                             *     `full` reaches every record; `owner` reaches only records the caller
                              *     owns, so an affordance rendered from an `owner` action must be
-                             *     gated on the row's owner or it will meet a 403.
+                             *     gated on the record's owner or it will meet a 403.
                              */
                             scope_by_action: {
                                 [key: string]: "full" | "owner";
                             };
                             /**
-                             * @description The fields each action opens, ON A ROW THE CALLER OWNS — the widest
-                             *     set any single row admits, since ownership is a property of a row
+                             * @description The fields each action opens, ON A RECORD THE CALLER OWNS — the widest
+                             *     set any single record admits, since ownership is a property of a record
                              *     and this endpoint is asked about an entity. ABSENT means all
                              *     fields; it never means none. An EMPTY list means exactly none, and
                              *     is emitted rather than dropped: a policy may grant the scope while
-                             *     opening no field (`fields: []`), and the write floor then refuses
+                             *     opening no field (`fields: []`), and the server then refuses
                              *     every field. Absence and `[]` are opposite answers and both are
                              *     reachable. Read together with `scope_by_action`: where an `owner`
                              *     grant contributed, that part of the list applies only to the
-                             *     caller's own rows.
+                             *     caller's own records.
                              */
                             fields_by_action: {
                                 [key: string]: string[] | null;
@@ -3586,7 +4688,11 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ToolCallBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
         };
@@ -3705,7 +4811,11 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["StateMachineReplayBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
         };
@@ -3787,7 +4897,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TraceReplayBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
             /** @description trace_not_found / legacy_trace_not_available */
@@ -3923,7 +5037,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                /** @description The audit row-table to list. */
+                /** @description The audit log to list. */
                 log: "binding_violations" | "topic_refusals";
             };
             cookie?: never;
@@ -3966,7 +5080,11 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SnapshotImportBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
         };
@@ -3980,7 +5098,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["JsonObject"];
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BulkImportBody"];
+            };
+        };
         responses: {
             200: components["responses"]["OkEnvelope"];
         };