aimeat 2.1.0 → 2.3.0

package/dist/src/generated/api-types.d.ts

@@ -738,7 +738,10 @@ export interface paths {
          * @description Returns the requesting app and the exact scopes (with descriptions) for the consent UI to
          *     render, plus `app_owner` (the app's owner name) and `origin_bound` (the redirect origin is
          *     verified to be this very app's subdomain) — together these let the consent page auto-approve
-         *     the signed-in owner's OWN app, matching the silent-bridge policy. Unguessable id; no auth.
+         *     the signed-in owner's OWN app, matching the silent-bridge policy. `app_icon` and
+         *     `app_description` come from the app manifest and are display-only: they give a first-time
+         *     visitor something to recognise the app BY, never part of the authorization decision.
+         *     Unguessable id; no auth.
          */
         get: operations["appGrantRequest"];
         put?: never;
@@ -763,8 +766,9 @@ export interface paths {
          * @description The owner, authenticated on the apex SPA, approves a pending request. The node mints a
          *     single-use authorization code and returns the app's `redirect_url` (carrying the code +
          *     state) for the browser to navigate back to the app. The optional `scopes` array grants a
-         *     SUBSET of the requested scopes (the "Advanced" picker) — values not in the request are
-         *     ignored; omit to grant everything requested.
+         *     SUBSET of the requested scopes (the consent page's per-scope checkboxes, revealed by "Show
+         *     the exact permissions") — values not in the request are ignored; omit to grant everything
+         *     requested.
          */
         post: operations["appGrantConsent"];
         delete?: never;
@@ -1661,6 +1665,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/prompts/build-extension": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Canonical "build an AIMEAT server extension" prompt
+         * @description The node-served, single-source-of-truth extension-building prompt — the SAME text the profile Extensions tab copies, so the tab, an agentic coder, the node:aimeat-extension-builder skill and llms.txt cannot drift apart. Covers the sandbox ctx surface (memory, fetch, files, caller, config, log, hash, now), the manifest and its input/output schemas, secret config fields, binary file I/O, the `commercial` block that prices an action and the `exchange` flag that lists it on the market, and how to install and activate the result. data.prompt is the complete copy-paste prompt; data.body is the platform core the tab wraps its own header around. Public.
+         */
+        get: operations["getBuildExtensionPrompt"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/prompts/appdev-flow": {
         parameters: {
             query?: never;
@@ -2260,7 +2284,7 @@ export interface paths {
         };
         /**
          * List the caller-owner's EXCHANGE entitlements (EXCHANGE / TARGET-045)
-         * @description Every metered entitlement the caller's owner holds as consumer, with live spend + budget. Response `data`: `{ entitlements: [{ entitlement_id, provider, ext, action, unit, price_per_call, rake_percent, contract_ref, state, budget: { cap_units, spent_units, remaining_units, calls } }] }`.
+         * @description Every metered entitlement the caller's owner holds as consumer, with live spend + budget. A right belongs to the HUMAN who pays for it, so one record covers the owner, their agents, their apps and their ecosystem apps alike; `callers` breaks the totals down by the principal that actually made each call. Response `data`: `{ entitlements: [{ entitlement_id, provider, ext, action, unit, price_per_call, rake_percent, contract_ref, state, budget: { cap_units, spent_units, remaining_units, calls }, callers: [{ gaii, calls, spent_units, carried_units, last_used_at }] }] }`.
          */
         get: operations["exchangeListEntitlements"];
         put?: never;
@@ -2295,6 +2319,90 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/app-grants/{grantId}/spend-cap": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * How much of your money a connected app may spend
+         * @description The `contract:spend` scope answers WHETHER an app may buy on your behalf; this answers how much. A yes with no number is a blank cheque, and until an app could be named apart from its owner the question could not even be asked — an app grant presents the owner's own GHII, so at the money layer a call from an app was indistinguishable from the person's own. Body: `{ cap_morsels: number | null, reset?: boolean }`. GET /v1/app-grants carries the same three fields back (`can_spend`, `spend_cap_morsels`, `spent_morsels`) so Profile > Access can render the dial. `null` removes the ceiling (the scope alone); `0` stops the app spending without withdrawing anything else it was trusted with; `reset: true` puts the counter back to zero. Only morsel charges count against it — money is denominated in micro-units and summing the two into one ceiling would conflate different numbers. Owner-only.
+         */
+        patch: operations["appGrantSetSpendCap"];
+        trace?: never;
+    };
+    "/v1/exchange/entitlements/merge": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Fold per-caller rights into the one right their owner holds (operator)
+         * @description Migration for rights minted before they were keyed to the owner. Only the human has a balance — `debitBalance` resolves every agent to its owner before touching a row — so a right keyed to the exact caller left one person holding several contracts for one product, all drawing on the one wallet. Once the key moved to the owner, those caller-keyed records stop resolving and their history would simply stop being found; this carries it across. Calls and spend are summed, each source becomes a row in the surviving record's caller breakdown, and every absorbed record is archived to contract history first. Surviving TERMS are the most recently created ones, because that is the last set the human agreed to; groups where an absorbed record priced differently are flagged `terms_changed`, because that changes what a call costs those callers. Rails are never merged (morsels and money micro-units are different numbers). Defaults to a DRY RUN — pass `{ "dry_run": false }` to apply. Operator-only.
+         */
+        post: operations["exchangeMergeEntitlements"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/grants": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Everyone you are carrying, and what it has cost you
+         * @description Every grant the caller's owner has ISSUED, with the accumulated cost of each. `?app_id=` narrows to the grants one app's approvals created. Response `data`: `{ grants: [{ consumer_gaii, ext, action, capability, list_price_per_call, carried_units, cap_carried_units, reason, state, budget }], count, carried }`, where `carried` totals the cost per rail (morsels / EUR / USD).
+         */
+        get: operations["exchangeListGrants"];
+        put?: never;
+        /**
+         * Carry a consumer's access instead of billing them — issue an EXCHANGE grant
+         * @description The provider decides who may use their capability without paying for it: "only the members I approve may use this app; everyone else pays". A grant is an entitlement priced at zero over the provider's OWN listing, held in its own key space, so it never overwrites a contract the consumer bought and stepping aside returns them to it. It is read at the one settlement chokepoint every metered surface shares, so it holds on the app-tool endpoint, the raw extension route, the MCP twin and the commerce checkout alike. The consumer settles NOTHING in either half of the price — the pacing morsels burn from the PROVIDER's wallet, since a carried member paying the throttle is still a member paying. What the provider is giving away is counted (`carried_units` accumulates the list price per call) and can be bounded (`cap_carried_units`). Requires scope `exchange:grant`, so an app issuing these on an owner's approval must say so. Body: `{ consumer, offering_id, cap_carried_units?, note?, app_id?, reason? }`. Returns `{ grant }`.
+         */
+        post: operations["exchangeIssueGrant"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/grants/revoke": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Withdraw a grant — one, or every grant an app approval issued
+         * @description Immediate: the next call reads a non-active grant and falls back to whatever the consumer bought for themselves, which for most of them is nothing. Two forms — `{ consumer, offering_id }` for one, or `{ app_id, role?, consumer? }` for every grant issued under an approval being taken back, so an app demoting a member does not have to remember each listing. Provider-only; requires scope `exchange:grant`. Returns `{ revoked, grants }`.
+         */
+        post: operations["exchangeRevokeGrant"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/exchange/proposals": {
         parameters: {
             query?: never;
@@ -2419,6 +2527,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/exchange/earnings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What you have EARNED and not yet been paid — the seller's accrued payables (EXCHANGE / TARGET-045)
+         * @description A money-priced metered call settles through the ACCRUAL rail: no per-call PSP charge and no custodial escrow — each call books the seller's net (price − platform rake) as a `pending` payable. This reads that book for the caller. Owner-scoped by the money identity (the same key the wallet uses), so an owner's agent or a granted app reads the OWNER's earnings and never another seller's; `wallet:read` gates non-owner principals. Returns `{ seller, currencies: { EUR: { pending, settled, total, entries } }, entries: [{ tracking_code, amount, currency, method, status, at, reference, buyer }], count, note }` — amounts in the currency's integer micro-units. READ-ONLY: it does not pay out, invoice, or move an entry from `pending` to `settled`.
+         */
+        get: operations["exchangeEarnings"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/exchange/work": {
         parameters: {
             query?: never;
@@ -2516,18 +2644,81 @@ export interface paths {
         };
         /**
          * One EXCHANGE offering's full detail — I/O schema, call recipe, usage stats (public) (TARGET-045)
-         * @description Everything a human or agent needs to judge fit and integrate: the offering, the capability's `input_schema`/`output_schema`, a `call_recipe` (the contract IS the access — you call `POST /v1/ext/{ext}/{action}` as yourself, no separate API key), and usage `stats` (reputation). Public. Returns `{ offering, capability, call_recipe, stats }`.
+         * @description Everything a human or agent needs to judge fit and integrate: the offering, the capability's `input_schema`/`output_schema`, a `call_recipe` (the contract IS the access — you call `POST /v1/ext/{ext}/{action}` as yourself, no separate API key), and usage `stats` (reputation). Public. Returns `{ offering, capability, call_recipe, stats, pacing, odps }`. `pacing.toll_morsels` is the morsel BURN each call costs the consumer to bound consumption rate — not a price: nobody is credited it, and calling your own capability is free. `pacing.source` is `capability` when the provider declared it (`tollMorsels` on the tool/action/offer) and `node` when the node default applies. `odps` points at the same listing rendered as an Open Data Product Specification v4.1 document.
          */
         get: operations["exchangeOfferingDetail"];
         put?: never;
         post?: never;
-        /** Delist one of your EXCHANGE offerings (TARGET-045) */
+        /**
+         * Delist one of your EXCHANGE offerings (TARGET-045)
+         * @description Delists a hand-authored listing. A PROJECTED listing (`auto: true`, TARGET-050) exists because its SOURCE says so — the app-tool manifest's `exchange` flag, the extension action's `commercial.exchange`, or the agent offer's `exchange` — so delisting it here would simply come back on the next reconcile: this returns 409 `SOURCE_MANAGED` and names the source to turn off instead. Pass `?force=1` to delist anyway (until the next reconcile). Delisting never affects a CONTRACT.
+         */
         delete: operations["exchangeDelistOffering"];
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
+    "/v1/exchange/offerings/{id}/odps": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * One EXCHANGE offering as an Open Data Product Specification v4.1 document (public) (TARGET-045)
+         * @description The listing rendered in the Linux Foundation's **Open Data Product Specification** (ODPS) v4.1 — the interoperable descriptor an outside catalogue or a negotiating agent can read without knowing anything about AIMEAT. Derived on read from the offering (never stored in ODPS form), so it cannot drift from the listing it describes. Carries `product.details`, `dataAccess` (the metered REST call plus the MCP surface), `pricingPlans` (base price + every bundle/subscription plan), `license` (AIMEAT usage terms as ODPS rights + restrictions), `dataHolder`, `paymentGateways`, and — when the provider committed to them — `SLA` and `dataQuality`. AIMEAT-specific truth (metered coordinate, pinned interface + I/O schema, call recipe, provenance, projection source, OBSERVED usage) travels under `product.x-aimeat`, which keeps the document valid against the official ODPS schema. Returns `{ odps_version, odps }` in the AIMEAT envelope; `?format=yaml` serves the raw YAML instead.
+         */
+        get: operations["exchangeOfferingOdps"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/offerings/{id}/odps.yaml": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * One EXCHANGE offering as an ODPS v4.1 YAML document (public) (TARGET-045)
+         * @description Same document as `GET /v1/exchange/offerings/{id}/odps`, served raw as `text/yaml` — the format the Open Data Product Specification leads with, so the URL can be handed straight to an ODPS-aware tool.
+         */
+        get: operations["exchangeOfferingOdpsYaml"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/reconcile": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reconcile your EXCHANGE listings against their sources (TARGET-050)
+         * @description The EXCHANGE listing is a PROJECTION of its source: an app-tool manifest entry with `exchange: true`, an extension action with `commercial.exchange: true`, or an agent offer with `exchange: true` (and visibility `public`). Writing any of those projects it automatically — this is the explicit handle. `dry_run` reports what WOULD change and writes nothing (not even an interface snapshot). `migrate` adopts hand-authored listings into the model: it flips the flag ON in their source and keeps their `offeringId`, so existing entitlements referencing `offering:{id}` keep resolving; a listing whose source is gone is reported as an orphan and left untouched. Scope a run with `app_id`/`ext`/`agent`. Idempotent. A CONTRACT is never touched — entitlements keep the interface version and the price they were signed at. Returns `{ owner, dryRun, changes[], created, updated, adopted, delisted, unchanged, skipped }` (+ `orphans`, `flagged` when migrating); each change carries `action`, `offeringId`, `kind`, `label`, `unit`, `currency` and, for a skip, the `reason` (SCHEMA_REQUIRED, NOT_PRICED, TOOL_UNBOUND, NOT_PUBLIC, INVALID_TOOL_MANIFEST, INVALID_OFFERS_DOC).
+         */
+        post: operations["exchangeReconcileOfferings"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/exchange/offerings/{id}/consumers": {
         parameters: {
             query?: never;
@@ -3284,7 +3475,14 @@ export interface paths {
         /** List storage items */
         get: operations["listStorage"];
         put?: never;
-        /** Upload file */
+        /**
+         * Upload file
+         * @description Three request shapes. Prefer **presigned** for anything over ~1 KB: JSON with
+         *     `mode: "presigned"` stores no bytes and answers with an `upload_url` to `PUT` the raw file to
+         *     (see `PUT /v1/upload/{token}`). The inline JSON form base64-encodes the file into the request
+         *     body, which inflates it by 4/3 and must therefore fit inside the node's JSON body limit — a
+         *     ceiling separate from, and usually lower than, the storage quota.
+         */
         post: operations["uploadFile"];
         delete?: never;
         options?: never;
@@ -3322,6 +3520,8 @@ export interface paths {
         /**
          * Download file
          * @description Returns raw bytes by default (supports Range headers for partial downloads). With `mode=handle`, returns a JSON handle (resource_uri + presigned, TTL-limited download_url + metadata) instead of bytes — used by MCP clients so binary content never enters the model context. With `mode=inline`, returns small (<= 32 KB) text files inline as JSON; larger or non-text files are rejected with 413.
+         *
+         *     Scope: this route reads the CALLER's own namespace only — files are keyed by (owner, key), so a file owned by anyone else is absent here and answers 404. To read a file someone else owns (an owner's upload for one of their agents, a DM or task attachment, a group/workspace share) use `GET /v1/pub/{gaii}/{key}`, which runs the consent/visibility guard.
          */
         get: operations["downloadFile"];
         put?: never;
@@ -4514,6 +4714,74 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/commerce/payout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Which payout rails can pay you, and what each needs (owner) (TARGET-042)
+         * @description The seller's settlement rails reported apart, because they are different things: **Stripe** moves real currency (EUR/USD) onto YOUR OWN Stripe account using the secret key you brought (you are the merchant of record; the node holds neither key nor funds), **x402** settles a stablecoin on-chain straight to an address you control, and **invoice** captures nothing at all and books the obligation for you to bill offline. Returns `{ x402: { enabled, network, testnet, configured, address, currencies, assets, note }, stripe: { configured, provider, keyHint, currencies, note }, invoice: { available, currencies, note } }`. `currencies` and `assets` are READ FROM THE NODE'S NETWORK REGISTRY, so they list only what this node can really settle: `assets` carries `{ currency, symbol, address, decimals }` per settleable currency (USD → USDC, EUR → EURC on the Base networks). ONE payout address receives every asset. A money sale over x402 with no address fails with SELLER_NO_X402_ADDRESS — this is the read that tells you before it happens.
+         */
+        get: operations["commercePayoutStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/commerce/payout/x402": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Set your stablecoin (x402) payout address (owner) (TARGET-042)
+         * @description Stores the EVM account address a stablecoin sale settles to. ONE address receives every settlement asset the node's network carries (USDC for a USD price, EURC for a EUR one), so there is no per-currency setting. MERGED into your payment-settings record: your Stripe credentials in the same record are untouched (and the reverse holds — setting Stripe no longer clears this). 400 INVALID_ADDRESS unless the value is `0x` + 40 hex characters. Responds `{ configured, address, network, currencies, enabled, checked }`, where `currencies` is what this node can actually settle to that address.
+         */
+        put: operations["commercePayoutX402Set"];
+        post?: never;
+        /**
+         * Remove your stablecoin (x402) payout address (owner) (TARGET-042)
+         * @description Clears only the payout address. Card and invoice settlement through your Stripe credentials is unaffected; stablecoin sales (USDC and EURC alike) fail until an address is set again.
+         */
+        delete: operations["commercePayoutX402Clear"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/commerce/payout/stripe": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Set your own Stripe secret key for card settlement (owner)
+         * @description Stores the Stripe secret key that card sales of YOUR items settle on. There is no node-level or platform key: the charge runs on your account, you are the merchant of record, Stripe did your KYC, and this node holds neither the funds nor a claim on them. MERGED into your payment-settings record, so your x402 payout address is untouched. The secret is stored server-side and is NEVER returned by any endpoint; reads report only `keyHint` (last four characters). 400 INVALID_PSP unless `secret_key` is 8-200 characters. Responds `{ configured, provider, keyHint, note }`.
+         */
+        put: operations["commercePayoutStripeSet"];
+        post?: never;
+        /**
+         * Remove your Stripe credentials (owner)
+         * @description Clears only the Stripe credentials. Your x402 payout address is untouched and invoice settlement still works; card sales fail with PSP_NOT_CONFIGURED until credentials are set again.
+         */
+        delete: operations["commercePayoutStripeClear"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/commerce/checkout-sessions": {
         parameters: {
             query?: never;
@@ -4642,7 +4910,7 @@ export interface paths {
         };
         /**
          * WebMCP-shaped tool listing of an app (public)
-         * @description The app's PUBLIC apps.{appId}.tools manifest served as WebMCP tool descriptors (name, description, inputSchema — the fields document.modelContext.registerTool takes) plus the AIMEAT payment contract per tool: fulfillment 'call' | 'task', and for priced tools the morsel/micro-unit money price with a ready-made checkout line item. The page itself registers the same tools in-browser via /v1/libs/aimeat-webmcp.js. 404 when the app declares no public manifest (TARGET-034 phase C).
+         * @description The app's PUBLIC apps.{appId}.tools manifest served as WebMCP tool descriptors (name, description, inputSchema — the fields document.modelContext.registerTool takes) plus the AIMEAT payment contract per tool: fulfillment 'call' | 'task', and for priced tools the morsel/micro-unit money price with a ready-made checkout line item. The page itself registers the same tools in-browser via /v1/libs/aimeat-webmcp.js (TARGET-034 phase C). Also carries `app_surface`: the app's public agent-facing description — declared scopes, SKILL.md packs bound to the app, bundled crew-defs, and live EXCHANGE listings for its tools. A published app with no public tool manifest answers 200 with an empty `tools` array (and a manifest for an app this node does not host still lists its tools, without `app_surface`). 404 means neither exists, or the app is access-code gated, priced, or operator-hidden. A PRIVATE manifest reads exactly like an absent one.
          */
         get: operations["appWebmcpListing"];
         put?: never;
@@ -4684,7 +4952,7 @@ export interface paths {
         put?: never;
         /**
          * UCP checkout — create session
-         * @description Universal Commerce Protocol (2026-04-08) shaped checkout over the commerce core. Every response carries ucp.version + ucp.capabilities; the UCP-Agent header (platform profile URL) is fetched best-effort for capability negotiation. Item ids: "offer:<agentGaii>:<offerId>" or "org-offering:<owner>/<slug>:<agentGaii>:<offerId>".
+         * @description Universal Commerce Protocol (2026-04-08) shaped checkout over the commerce core. Every response carries ucp.version + ucp.capabilities; the UCP-Agent header (platform profile URL) is fetched best-effort for capability negotiation. Item ids: "offer:<agentGaii>:<offerId>" or "app-tool:<owner>/<appId>:<tool>".
          */
         post: operations["ucpCreateCheckoutSession"];
         delete?: never;
@@ -6103,7 +6371,16 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * Read the app's unpublished draft (staging) content
+         * @description Returns the current draft slot for `{owner}/{filename}` — the base64 content plus its size,
+         *     mime type and manifest. Owner-only; the caller is resolved from the token, so a draft is
+         *     never readable by anyone else. This is the read side of the draft slot: an editing client
+         *     that reloads must be able to load the working copy BACK, otherwise it can only re-fetch the
+         *     LIVE bytes and would silently overwrite the draft on its next save. The `?preview=` URL is
+         *     not usable for this — on an app-origin node it redirects to the isolated (CORS-less) origin.
+         */
+        get: operations["getAppDraft"];
         /**
          * Save the app's unpublished draft (staging)
          * @description Upserts the single draft slot for `{owner}/{filename}` — the staging copy of the NEXT version.
@@ -6150,6 +6427,37 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/apps/{owner}/{filename}/frame-token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mint a frame grant letting ONE origin embed this app
+         * @description Returns a `frame_url` usable as an `iframe` src. An app origin refuses framing by default
+         *     (`frame-ancestors 'self' <apex>`); a frame grant widens that by exactly the ONE origin named
+         *     in the token, and only for responses carrying it.
+         *
+         *     The grant is issued to the CALLING page's `Origin` header — never to an origin supplied in the
+         *     body, which would let a page request permission on someone else's behalf. Owner-only: a grant
+         *     to frame an app you do not own is a clickjacking primitive. A malformed, expired or
+         *     wrong-app grant simply leaves the strict policy in place, so framing fails closed.
+         *
+         *     Deliberately one origin per grant rather than a list of allowed origins on the app: a list
+         *     grows with how many apps the owner has, and past roughly seventy it overruns a typical reverse
+         *     proxy's header buffer and every app origin starts answering 502.
+         */
+        post: operations["mintAppFrameToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/apps/{owner}/{filename}/publish-draft": {
         parameters: {
             query?: never;
@@ -11172,14 +11480,23 @@ export interface paths {
         };
         /**
          * Download public file
-         * @description Download a file by owner GAII and key. Public files need no auth.
-         *     Non-public files apply the same consent/visibility rules as memory:
-         *     the caller must hold a matching consent grant or (for `visibility:'group'`)
-         *     be a member of the file's sharing group; `organism.{id}` grants resolve for
-         *     active organism members. Every read is written to the consent audit log.
-         *     An authenticated caller without access gets 403; anonymous/unauthenticated
-         *     callers get 404 (file existence is hidden on public URLs).
+         * @description Download a file by owner GAII and key. This is the ONE door for reading a file the caller
+         *     does not own — `GET /v1/storage/{key}` is namespaced to the caller and cannot reach it.
+         *     Public files need no auth. Non-public files apply the same consent/visibility rules as
+         *     memory: `visibility:'owner'` admits every agent and app of the SAME owner (this is how a
+         *     document an owner uploads reaches that owner's own agent — upload with `visibility: owner`,
+         *     then the agent reads it with its own token), `members` any authenticated node user,
+         *     `group`/`workspace` their members, and a private file only with a matching consent grant;
+         *     `organism.{id}` grants resolve for active organism members. Denied reads are written to the
+         *     consent audit log. An authenticated caller without access gets 403; anonymous/
+         *     unauthenticated callers get 404 (file existence is hidden on public URLs).
          *     Supports wildcard keys with path separators.
+         *
+         *     With `mode=handle` the response is a presigned, TTL-limited `download_url` plus metadata
+         *     instead of the bytes, so an agent or liaison can hand the URL to a fetch or a document
+         *     parser without pulling binary through a tool result. The access decision is identical. A
+         *     handle for someone else's file expires sooner (15 min) than one for your own (1 h), so it
+         *     cannot long outlive a revoked grant.
          */
         get: operations["getPublicFile"];
         put?: never;
@@ -12961,11 +13278,8 @@ export interface paths {
         /**
          * Get merged agent directives
          * @description Returns the merged view of agent directives combining system defaults,
-         *     an optional edition-locked enterprise layer (company Secretary on the
-         *     Enterprise edition), owner defaults, and agent-specific overrides. Rules
-         *     are ordered by source priority: system, enterprise, owner, agent. The
-         *     enterprise layer is read-only (`locked:true`); `enterprise_locked` flags
-         *     its presence.
+         *     owner defaults, and agent-specific overrides, ordered by source priority:
+         *     system, owner, agent.
          */
         get: operations["getAgentDirectives"];
         /**
@@ -17595,6 +17909,12 @@ export interface components {
             flagCount: number;
             /** @description GAII of the entry owner (included in public reads via /v1/memory/{gaii}/{key}) */
             owner_gaii?: string;
+            /**
+             * @description Owner-scope listings only. Other same-owner identities holding this SAME key. Memory is
+             *     keyed by the writer, and an owner-scope read resolves GHII-first, so those copies are
+             *     absent from the response — this names them instead of letting the collision be invisible.
+             */
+            also_under?: string[];
             /** @description Data Decision Context — structured metadata for agent decision-making */
             _ddc?: {
                 flagCount?: number;
@@ -18971,6 +19291,31 @@ export interface components {
          * @enum {string}
          */
         TaskStatus: "draft" | "queued" | "revision_requested" | "active" | "paused" | "done" | "failed" | "stalled";
+        /** @description One file handed to the agent WITH the task. Only a REFERENCE is stored, never the bytes. On create, `ref` (and optionally `name`) is supplied; the server verifies the file exists and that the CREATOR can read it, then fills `mime` and `size` from the stored file. On read, the entry is authorized again as the READING principal and carries `access` plus a presigned `download_url` when granted — so a revoked grant stops handing out URLs on the next read. */
+        AgentTaskFileRef: {
+            /**
+             * @description "<ownerGaii>/<storage key>" (a bare key means the caller's own storage).
+             * @example alice@aimeat-fi-001-genesis/invoices/2026-07.pdf
+             */
+            ref: string;
+            name?: string;
+            readonly mime?: string;
+            readonly size?: number;
+            /** @enum {string} */
+            readonly access?: "granted" | "denied" | "missing";
+            /** @description Why a non-granted read was refused (e.g. consent_denied, not_found). */
+            readonly reason?: string;
+            /** @description Presigned, TTL-limited GET. Present only when access is granted. */
+            readonly download_url?: string;
+            readonly expires_in_seconds?: number;
+        };
+        /** @description What the agent needs in order to do the task — knowledge, memory, and files. */
+        AgentTaskResources: {
+            knowledge_packages?: string[];
+            memory_keys?: string[];
+            memory_prefixes?: string[];
+            files?: components["schemas"]["AgentTaskFileRef"][];
+        };
         AgentTask: {
             /** Format: uuid */
             id: string;
@@ -18988,6 +19333,7 @@ export interface components {
             createdAt: string;
             /** Format: date-time */
             updatedAt: string;
+            resources?: components["schemas"]["AgentTaskResources"];
             /** @description Memory key (agent namespace) where the task's deliverable was published, if any. */
             deliverableKey?: string;
             rating?: components["schemas"]["AgentTaskRating"];
@@ -19030,14 +19376,10 @@ export interface components {
         };
         AgentDirectives: {
             purpose?: string;
-            /** @description True when an edition-locked enterprise directive layer is present (a company Secretary on the AIMEAT Enterprise edition). Such rules carry source 'enterprise' + locked:true and are read-only. */
-            enterprise_locked?: boolean;
             rules?: {
                 text?: string;
                 /** @enum {string} */
-                source?: "system" | "enterprise" | "owner" | "agent";
-                /** @description True for read-only enterprise-layer rules (cannot be edited via PUT). */
-                locked?: boolean;
+                source?: "system" | "owner" | "agent";
             }[];
             memoryAreas?: {
                 key?: string;
@@ -22859,6 +23201,33 @@ export interface operations {
             };
         };
     };
+    getBuildExtensionPrompt: {
+        parameters: {
+            query?: {
+                /** @description Language for the built extension's own user-facing text; the instructions stay English */
+                lang?: "en" | "fi";
+                /** @description The account the extension will be installed for, so namespaces read concretely (defaults to the caller when authenticated) */
+                owner?: string;
+                /** @description What the extension should do, embedded in the prompt header */
+                idea?: string;
+                /** @description txt returns the full prompt as text/plain instead of the JSON envelope */
+                format?: "txt";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The extension build prompt (JSON envelope with prompt + body, or text/plain with format=txt) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     getAppdevFlowPrompt: {
         parameters: {
             query?: {
@@ -23911,6 +24280,136 @@ export interface operations {
             404: components["responses"]["AimeatError"];
         };
     };
+    appGrantSetSpendCap: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                grantId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Ceiling in morsels across the life of the grant. null removes it. */
+                    cap_morsels?: number | null;
+                    /** @description Put the spent counter back to zero. */
+                    reset?: boolean;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeMergeEntitlements: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /**
+                     * @description Report what would be merged without writing.
+                     * @default true
+                     */
+                    dry_run?: boolean;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeListGrants: {
+        parameters: {
+            query?: {
+                /** @description Only grants issued under this app's approvals. */
+                app_id?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeIssueGrant: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The principal to carry — an owner name, their GHII, or one of their agents' GAII. Must resolve on this node; a name that no call would ever match is rejected rather than stored. */
+                    consumer: string;
+                    /** @description The provider's own listed offering. Someone else's is a 404. */
+                    offering_id: string;
+                    /** @description Ceiling on what the provider will carry, in the listing's unit. Omit for no ceiling. */
+                    cap_carried_units?: number;
+                    /** @description Free text the provider records with the approval. */
+                    note?: string;
+                    /** @description Consuming app id ("owner/filename") for the per-app cost surface. */
+                    app_id?: string;
+                    /** @description The app + role this grant stands for, so a demotion can withdraw exactly what the approval created. */
+                    reason?: {
+                        app_id?: string;
+                        role?: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeRevokeGrant: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    consumer?: string;
+                    /** @description Withdraw one grant; requires consumer. */
+                    offering_id?: string;
+                    /** @description Withdraw every grant this app's approvals issued. */
+                    app_id?: string;
+                    /** @description With app_id */
+                    role?: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
     exchangeListProposals: {
         parameters: {
             query?: never;
@@ -24025,6 +24524,27 @@ export interface operations {
             200: components["responses"]["AimeatSuccess"];
         };
     };
+    exchangeEarnings: {
+        parameters: {
+            query?: {
+                /** @description Only pending (owed) or settled (paid) entries. */
+                status?: "pending" | "settled";
+                /** @description Narrow to one currency (e.g. EUR). */
+                currency?: string;
+                /** @description Max payable records to read (default 200 */
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+        };
+    };
     exchangeListWork: {
         parameters: {
             query?: {
@@ -24154,7 +24674,18 @@ export interface operations {
                     plans?: Record<string, never>[];
                     title?: string;
                     description?: string;
-                    provenance?: Record<string, never>;
+                    /** @description Provider attestation, validated (400 INVALID_PROVENANCE): { source, legalBasis, consentStatus, retention, transformations, snapshotHash (SHA-256), lineage[{source,transform,at}] }. The node stamps odpsVersion. */
+                    provenance?: {
+                        source?: string;
+                        legalBasis?: string;
+                        consentStatus?: string;
+                        retention?: string;
+                        transformations?: string;
+                        snapshotHash?: string;
+                        lineage?: Record<string, never>[];
+                    };
+                    /** @description ODPS v4.1 fields the node cannot derive, validated (400 INVALID_ODPS): productType, valueProposition, categories, standards, useCases, contentSample, logoURL, sla[{dimension,objective,unit}], dataQuality[{dimension,objective,unit}], dataHolder{legalName,…}, license{geographicalArea,applicableLaws,exclusive,…}. Surfaced at GET /v1/exchange/offerings/{id}/odps.yaml. */
+                    odps?: Record<string, never>;
                     tags?: string[];
                     usage_terms: {
                         derivatives?: boolean;
@@ -24189,7 +24720,29 @@ export interface operations {
     };
     exchangeDelistOffering: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description Delist a source-managed listing anyway (it returns on the next reconcile). */
+                force?: "1";
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            404: components["responses"]["AimeatError"];
+            409: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeOfferingOdps: {
+        parameters: {
+            query?: {
+                /** @description Serve the raw ODPS YAML document instead of the JSON envelope. */
+                format?: "yaml";
+            };
             header?: never;
             path: {
                 id: string;
@@ -24202,6 +24755,60 @@ export interface operations {
             404: components["responses"]["AimeatError"];
         };
     };
+    exchangeOfferingOdpsYaml: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The ODPS v4.1 document. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/yaml": string;
+                };
+            };
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeReconcileOfferings: {
+        parameters: {
+            query?: {
+                dry_run?: "1";
+                migrate?: "1";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Report only; write nothing. */
+                    dry_run?: boolean;
+                    /** @description Adopt hand-authored listings (flag their source, keep the offeringId). */
+                    migrate?: boolean;
+                    /** @description Reconcile only this app's tool manifest. */
+                    app_id?: string;
+                    /** @description Reconcile only this extension's actions. */
+                    ext?: string;
+                    /** @description Reconcile only this agent's offers. */
+                    agent?: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
     exchangeOfferingConsumers: {
         parameters: {
             query?: never;
@@ -25185,6 +25792,17 @@ export interface operations {
                     };
                 };
             };
+            /**
+             * @description The payload was rejected. `error` carries the reason code from the shared manifest
+             *     validator for extension/cortex ZIPs (`INVALID_MANIFEST`, `MISSING_SCRIPT`,
+             *     `CODE_TOO_LARGE`, …) and `message` names the offending field.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Invalid token */
             401: {
                 headers: {
@@ -25192,7 +25810,20 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Token already used (single-use) */
+            /**
+             * @description The target already exists and belongs to another owner (extension uploads). The token
+             *     subject is what identifies the uploader; ownership is always checked.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description Token already used (single-use), or — for an extension upload without `update:true` in
+             *     the token meta — an extension of that name is already installed (`ALREADY_EXISTS`).
+             */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -25206,13 +25837,39 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description File exceeds size limit encoded in token */
+            /**
+             * @description `FILE_TOO_LARGE` — the body exceeds the per-file size limit encoded in the token, or
+             *     `QUOTA_EXCEEDED` — a storage upload would put the account over its total storage quota
+             *     (the same gate the inline `POST /v1/storage` applies; the token's limit caps one file,
+             *     the quota caps the account).
+             */
             413: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
+            /**
+             * @description Processing failed. The body carries a `reason` naming the failure. An extension upsert
+             *     whose storage write did not apply answers `UPDATE_FAILED` and states that the installed
+             *     version is unchanged — this endpoint never reports an unapplied write as success.
+             */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The manifest declares `type: secret` config but no encryption key is configured
+             *     (`ENCRYPTION_NOT_CONFIGURED`); set AIMEAT_ENCRYPTION_KEY.
+             */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     downloadViaToken: {
@@ -25287,6 +25944,24 @@ export interface operations {
         };
         requestBody: {
             content: {
+                "application/json": {
+                    key: string;
+                    /** @description Base64-encoded file bytes. Required unless `mode` is `presigned`. */
+                    data?: string;
+                    mime_type?: string;
+                    /**
+                     * @description Mint a one-shot upload URL instead of storing bytes now. The response carries `upload_url`, `upload_method`, `content_type`, `max_size_bytes` and `expires_in_seconds`.
+                     * @enum {string}
+                     */
+                    mode?: "presigned";
+                    /** @enum {string} */
+                    visibility?: "private" | "owner" | "group" | "workspace" | "members" | "public";
+                    /** @description Sharing group ID (required when visibility is 'group') */
+                    group_id?: string;
+                    /** @description One or more "{organismId}/{workspaceId}" (required when visibility is 'workspace'). */
+                    workspace_refs?: string[];
+                    federate?: boolean;
+                };
                 "multipart/form-data": {
                     /** Format: binary */
                     file?: string;
@@ -25299,8 +25974,22 @@ export interface operations {
             };
         };
         responses: {
+            /** @description Presigned mode — an upload URL was minted. No bytes were stored; `PUT` the file to `upload_url`. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             201: components["responses"]["AimeatSuccess"];
-            /** @description Storage quota exceeded */
+            /** @description An anonymous principal targeted a key outside `anonymous/*`. Applies to both the inline and the presigned form: the namespace fence is on the write, not on the representation. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Storage quota exceeded, or the file exceeds the per-file size limit */
             413: {
                 headers: {
                     [name: string]: unknown;
@@ -26965,6 +27654,89 @@ export interface operations {
             200: components["responses"]["AimeatSuccess"];
         };
     };
+    commercePayoutStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    commercePayoutX402Set: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description EVM account address: 0x followed by 40 hex characters. */
+                    address: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    commercePayoutX402Clear: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    commercePayoutStripeSet: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Your Stripe secret key (sk_live_… or sk_test_…). */
+                    secret_key: string;
+                    /** @description Provider label, default 'stripe'. */
+                    provider?: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    commercePayoutStripeClear: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
     listCheckoutSessions: {
         parameters: {
             query?: {
@@ -26994,14 +27766,12 @@ export interface operations {
                          * @default offer
                          * @enum {string}
                          */
-                        kind?: "offer" | "org-offering" | "app-tool" | "ext-call";
+                        kind?: "offer" | "app-tool" | "ext-call";
                         /** @description Provider agent GAII (or bare name for own agent) */
                         agent?: string;
                         offer_id?: string;
                         /** @description app-tool: the tool name from apps.{appId}.tools; ext-call: the action id */
                         tool?: string;
-                        /** @description org-offering: "creatorOwner/slug" */
-                        org?: string;
                         /** @description app-tool: "ownerName/appId"; ext-call: the extension name */
                         app?: string;
                         /** @description app-tool: buyer input forwarded to the capability invoke at completion */
@@ -27196,7 +27966,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description WebMCP tool listing */
+            /** @description WebMCP tool listing + the app's public agent-facing surface */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -27205,7 +27975,7 @@ export interface operations {
                     "application/json": Record<string, never>;
                 };
             };
-            /** @description No public tool manifest */
+            /** @description No such public app (missing, access-code gated, priced, or operator-hidden) */
             404: {
                 headers: {
                     [name: string]: unknown;
@@ -29653,6 +30423,48 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    getAppDraft: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                owner: string;
+                filename: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The draft content */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            filename?: string;
+                            /** @description base64-encoded draft HTML */
+                            content?: string;
+                            mime_type?: string;
+                            size?: number;
+                            /** Format: date-time */
+                            updated_at?: string;
+                            manifest?: Record<string, never>;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No draft exists for this app */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     saveAppDraft: {
         parameters: {
             query?: never;
@@ -29789,6 +30601,62 @@ export interface operations {
             };
         };
     };
+    mintAppFrameToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                owner: string;
+                filename: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Frame grant minted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            /** @description Use as an iframe src */
+                            frame_url?: string;
+                            /** @description The app's own origin */
+                            app_origin_url?: string;
+                            /** @description The one origin this grant names */
+                            granted_to?: string;
+                            expires_in_seconds?: number;
+                            note?: string;
+                        };
+                    };
+                };
+            };
+            /** @description The request carried no usable Origin header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No such app owned by the caller */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description App origins are disabled on this node */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     publishAppDraft: {
         parameters: {
             query?: never;
@@ -36772,12 +37640,27 @@ export interface operations {
         requestBody: {
             content: {
                 "application/json": {
-                    /** @description YAML manifest defining the extension metadata, actions, and limits */
-                    manifest: string;
+                    /**
+                     * @description Presigned mode: omit `manifest`/`scripts` and receive an `upload_url`; PUT a ZIP
+                     *     (manifest.yaml at root, scripts in scripts/) to it. Lets the mint and the upload
+                     *     happen in one command so the upload token is never transcribed.
+                     * @enum {string}
+                     */
+                    mode?: "presigned";
+                    /** @description YAML manifest defining the extension metadata, actions, and limits (required unless mode=presigned) */
+                    manifest?: string;
                     /** @description Key-value map of script filenames to JavaScript source code */
-                    scripts: {
+                    scripts?: {
                         [key: string]: string;
                     };
+                    /**
+                     * @description Presigned only. Upsert an already-installed extension instead of 409. Activation
+                     *     status, lifecycle stamps and the ext:{name} memory are preserved. Carried in the
+                     *     upload token meta.
+                     */
+                    update?: boolean;
+                    /** @description Presigned only. Activate immediately after install/update. */
+                    activate?: boolean;
                 };
             };
         };
@@ -38646,10 +39529,13 @@ export interface operations {
     };
     getPublicFile: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description Omit for raw bytes; `handle` returns a presigned download_url + metadata. */
+                mode?: "handle";
+            };
             header?: never;
             path: {
-                /** @description URL-encoded agent GAII */
+                /** @description URL-encoded owner GHII / agent GAII that owns the file */
                 gaii: string;
                 /** @description File key (may contain path separators) */
                 key: string;
@@ -38658,12 +39544,30 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description File content with appropriate Content-Type */
+            /** @description File bytes, or a JSON handle when `mode=handle` */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/octet-stream": string;
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            ref?: string;
+                            owner_gaii?: string;
+                            key?: string;
+                            /** @enum {string} */
+                            mode?: "handle";
+                            mime_type?: string;
+                            size?: number;
+                            visibility?: string;
+                            download_url?: string;
+                            /** @enum {string} */
+                            download_method?: "GET";
+                            expires_in_seconds?: number;
+                        };
+                    };
+                };
             };
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
@@ -41345,6 +42249,7 @@ export interface operations {
                         /** @default false */
                         done?: boolean;
                     }[];
+                    resources?: components["schemas"]["AgentTaskResources"];
                 };
             };
         };