aimeat 2.0.0 → 2.2.0

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

@@ -447,6 +447,52 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/unfurl": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Link preview (unfurl) metadata for a URL
+         * @description Fetch a URL server-side (SSRF-safe via safeFetch) and return its OpenGraph/Twitter-card
+         *     metadata so a pasted link can render as a rich preview card. Generic — usable by any client
+         *     (message threads, notebook, workspace docs). The page fetch is size-capped and content-type
+         *     checked; results are cached (~1h). A non-HTML target returns a hostname-only preview.
+         */
+        get: operations["unfurlLink"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/unfurl/image": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Proxy a link-preview image same-origin
+         * @description Fetch a preview image (typically the `image` from GET /v1/unfurl) THROUGH the node and stream
+         *     it back. Same-origin so the SPA's `img-src 'self' data: blob:` CSP is satisfied, and the
+         *     viewer's IP never reaches the third-party site. SSRF-safe, content-type checked (image/*), and
+         *     size-capped.
+         */
+        get: operations["unfurlImage"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/validate": {
         parameters: {
             query?: never;
@@ -664,7 +710,10 @@ export interface paths {
          *     **302-redirects** to the trusted apex consent page (`/v1/app-grant?req=...`) where the
          *     owner approves. `code_challenge_method` is `S256` (or `plain` for non-secure-context clients
          *     without crypto.subtle — real app origins are https/S256); `redirect_uri` must be on the
-         *     app origin (never the apex); `scope` must be drawn from the grantable scope set. With
+         *     app origin (never the apex), and when it lives on a **per-app subdomain** that subdomain
+         *     must map to exactly the requesting `app` (else `INVALID_REDIRECT_URI`) — a bound request
+         *     marks the pending request `origin_bound`, unlocking own-app auto-approve on the consent
+         *     page; `scope` must be drawn from the grantable scope set. With
          *     `response_mode=web_message` the consent page postMessages the code back to the app
          *     popup-opener (so the user stays in the app); the default `query` mode full-redirects.
          */
@@ -686,7 +735,10 @@ export interface paths {
         };
         /**
          * Read a pending app-grant request (for the consent page)
-         * @description Returns the requesting app and the exact scopes (with descriptions) for the consent UI to render. Unguessable id; no auth.
+         * @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.
          */
         get: operations["appGrantRequest"];
         put?: never;
@@ -763,8 +815,11 @@ export interface paths {
          * @description Called by the app from its own origin (CORS `*`). With `grant_type=authorization_code`
          *     (+ PKCE `code_verifier`) the node creates the persistent grant and returns a short-lived
          *     **scoped** access JWT (role `app`, the granted scopes, an `app_grant` claim) + a rotating
-         *     refresh token — never the owner's session. With `grant_type=refresh_token` it rotates the
-         *     refresh token and re-mints the access JWT. A revoked grant yields `401`.
+         *     refresh token — never the owner's session. The code-exchange response also carries `app`
+         *     (owner/filename) and `own` (origin-bound request approved by the app's own owner) so the
+         *     SDK's login-pill metadata matches the silent bridge. With `grant_type=refresh_token` it
+         *     rotates the refresh token and re-mints the access JWT **with the stored grant's scopes**
+         *     (a refresh never widens scopes on its own). A revoked grant yields `401`.
          */
         post: operations["appGrantToken"];
         delete?: never;
@@ -1606,6 +1661,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/prompts/appdev-flow": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Research-first appdev flow prompt (paste-able)
+         * @description The paste-able flow prompt a user gives an MCP-connected coding agent (Claude Code, OpenHands, Cursor) so every AIMEAT app build follows research → frame → propose → build → finish instead of coding cold: load node:aimeat-app-builder, call aimeat_appdev_overview, frame the tier/packs/iam decision, propose, build, then finish with agent face + template proposal + pitfall report. The user can always skip. Public.
+         */
+        get: operations["getAppdevFlowPrompt"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/library-packs": {
         parameters: {
             query?: never;
@@ -1614,7 +1689,7 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Library-pack registry index
+         * Library-pack registry index (community entries may carry self-reported proofs[] + proven_models)
          * @description The data-driven registry of every client-side library an AIMEAT app can include — SDK wrappers (/v1/libs), node-bundled cortex libs (/v1/cortex/<n>/libs) and vendored third-party capability packs (/lib). Compact index (no ai_doc/changelog): id, kind, category, description, rendered include line(s), requires, version, license, apiSurface, demoTemplateId, tierHint, interviewTriggers, sizeEstimate, status, scope, and (node packs) the optional AI-acceleration fields modelTier ("any" | "frontier" | "needs-doc" — the model strength a pack is reliably-and-accelerated on), proofs[] (the per-model AEB proof ledger: {model, verdict, testSet, evidence, tokens?, date}) and apiCaveat (for frontier packs — the one breaking-API idiom a weak model gets wrong from memory). See tools/aeb/acceleration-tiers.md. Two sources merge: scope "node" (the curated registry — every AI-facing library list derives from it: build-app prompt, GET /v1/libs, bootstrap, llms.txt) and scope "community" (active + public user-installed cortex extensions that ship a lib component; always status "preview", no tier/proofs — unvetted by the node). Public (CORS *).
          */
         get: operations["listLibraryPacks"];
@@ -1703,6 +1778,136 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/appdev/overview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * AppDev research overview (the big picture before building)
+         * @description One compact research surface for building apps ON AIMEAT: the caller's existing apps, library packs (per-model proof summaries), T1/T2/T3 app-shell templates, loadable skills (node:aimeat-app-builder first), curated + learned pitfalls (model-faceted), and prior template proposals. Indexes only with drill-down pointers; ?sections= for a partial fetch, ?model= for indicative model marking/filtering. Authenticated (owner or agent session).
+         */
+        get: operations["getAppdevOverview"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/appdev/pitfalls/learned": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The caller's learned appdev pitfalls (profile UI management surface)
+         * @description Full-body learned pitfall entries in the caller's owner scope (own GHII + every same-owner agent), any visibility; with include_shared=1 also other owners' public-shared entries (source: shared, read-only). Curated registry entries are served separately at GET /v1/appdev/pitfalls.
+         */
+        get: operations["listLearnedAppdevPitfalls"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/appdev/pitfalls/learned/{category}/{slug}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Delete an own learned pitfall (entry + manifest ref) */
+        delete: operations["deleteLearnedAppdevPitfall"];
+        options?: never;
+        head?: never;
+        /** Toggle share (platform-wide visibility) and/or status on an own learned pitfall */
+        patch: operations["updateLearnedAppdevPitfall"];
+        trace?: never;
+    };
+    "/v1/appdev/templates": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The caller's agent-proposed app templates (full manifests) */
+        get: operations["listAppdevTemplateProposals"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/appdev/templates/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One template proposal + the source app's live state */
+        get: operations["getAppdevTemplateProposal"];
+        put?: never;
+        post?: never;
+        /** Delete a template proposal */
+        delete: operations["deleteAppdevTemplateProposal"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/appdev/pitfalls": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Curated appdev-pitfall registry index
+         * @description Platform-level "what bites app builders" knowledge for AI agents building apps ON AIMEAT (apps, extensions, cortexes — never node development). Paginated index with total and facet counts (per applies-to scope and severity), sorted critical → warn → info. Public (CORS *).
+         */
+        get: operations["listAppdevPitfalls"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/appdev/pitfalls/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One curated appdev pitfall (full entry) */
+        get: operations["getAppdevPitfall"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/memory": {
         parameters: {
             query?: never;
@@ -2026,6 +2231,465 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/apps/cost": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Per-app EXCHANGE cost & contracts surface (EXCHANGE G3 / TARGET-045)
+         * @description Owner-scoped read that composes an app's priced EXCHANGE dependencies so the app-catalog can show, per app: its active contracts (metered entitlements), live consumption (spend + calls against each budget), an estimated per-call / remaining-budget cost, and the platform rake. Attribution is by the entitlement's `appId`; the caller only ever sees entitlements whose consumer is their own owner (strictly cross-owner). Generic — any app with priced dependencies uses it. LLM-usage attribution is out of scope for slice-1 (the usage ledger has no appId dimension yet); this composes the entitlement spend, which IS the per-app metered consumption record. Response `data`: `{ app_id, owner_ghii, active_contracts, total_contracts, totals: { morsels: { spent_units, calls, contracts }, money: {...} }, contracts: [{ entitlement_id, capability, provider, contract_ref, state, unit, currency, price_per_call, rake_percent, rake_per_call, escrow_party, budget: { cap_units, spent_units, remaining_units, calls }, estimated_calls_remaining }] }`.
+         */
+        get: operations["appCost"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/entitlements": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * 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 } }] }`.
+         */
+        get: operations["exchangeListEntitlements"];
+        put?: never;
+        /**
+         * Accept an EXCHANGE contract → mint a metered entitlement (EXCHANGE / TARGET-045)
+         * @description The WRITE side of the metered entitlement. The caller's owner accepts a negotiated contract to call a provider's extension action at a metered price. The per-call PRICE is read authoritatively from the provider (the ext action, or the app-tool's listing) — the request supplies only the BUDGET cap and the contract ref, so a consumer can neither undercut the provider nor be charged an unaccepted price. The entitlement's consumer is always the caller's own owner (strictly cross-owner). PREFERRED: pass `offering_id` (works for both ext-action and app-tool offerings; an app-tool contract is pinned to the offering's interface version). LEGACY: pass `ext` + `action` + `contract_ref` for a raw ext-action. Body: `{ offering_id?, ext?, action?, contract_ref?, cap_units?, plan_id?, app_id?, escrow_party? }`. Response `data`: `{ entitlement: {...} }`.
+         */
+        post: operations["exchangeAcceptContract"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/entitlements/off": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pause or revoke one of your EXCHANGE entitlements (EXCHANGE / TARGET-045)
+         * @description The consumer's off-switch. `mode: pause` is reversible (re-accept to resume); `mode: revoke` is terminal. Only the entitlement's own consumer may. Body: `{ ext, action, mode }`.
+         */
+        post: operations["exchangeEntitlementOff"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/proposals": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List contract-change proposals you are party to (EXCHANGE / TARGET-045)
+         * @description Every renegotiation proposal the caller is party to (incoming + outgoing), newest first. Returns `{ proposals, count }`.
+         */
+        get: operations["exchangeListProposals"];
+        put?: never;
+        /**
+         * Propose new terms for a live contract — renegotiation (EXCHANGE / TARGET-045)
+         * @description Either party renegotiates instead of blindly revoking + re-accepting. A consumer renegotiates their own contract; a PROVIDER renegotiates a specific consumer's contract (pass `consumer_gaii`). Propose a new per-call price and/or a new budget cap + a note. A message is delivered to the counterparty (Profile > Messages); nothing changes until they accept. Mutual consent is the authority. Body: `{ ext, action, consumer_gaii?, new_price_per_call?, new_cap_units?, note? }`. Returns `{ proposal }`.
+         */
+        post: operations["exchangeProposeChange"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/proposals/{id}/accept": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Accept a proposed contract change — supersede (EXCHANGE / TARGET-045)
+         * @description The COUNTERPARTY accepts: the old contract is archived to history (with its final spend + period) and a fresh one takes effect at the agreed terms. Returns `{ proposal, entitlement }`.
+         */
+        post: operations["exchangeAcceptProposal"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/proposals/{id}/decline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Decline a proposed contract change (EXCHANGE / TARGET-045)
+         * @description The counterparty declines; the contract is unchanged. Returns `{ proposal }`.
+         */
+        post: operations["exchangeDeclineProposal"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/proposals/{id}/withdraw": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Withdraw your own pending contract-change proposal (EXCHANGE / TARGET-045)
+         * @description The PROPOSER withdraws a pending proposal. Returns `{ proposal }`.
+         */
+        post: operations["exchangeWithdrawProposal"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/entitlements/history": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Your PAST (archived / superseded) contracts as consumer (EXCHANGE / TARGET-045)
+         * @description Contracts that were superseded by a renegotiation, with the old terms + final spend + archived_at. Returns `{ history, count }`.
+         */
+        get: operations["exchangeEntitlementHistory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/provider/history": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Your PAST (archived / superseded) contracts as provider (EXCHANGE / TARGET-045)
+         * @description Superseded contracts you sold, with the old terms + final spend. Returns `{ history, count }`.
+         */
+        get: operations["exchangeProviderHistory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/work": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List your AGENT-WORK items (EXCHANGE / TARGET-045 Gap 2)
+         * @description `?role=consumer` (default) or `?role=provider`. Returns `{ work, count, role }`.
+         */
+        get: operations["exchangeListWork"];
+        put?: never;
+        /**
+         * Start an AGENT-WORK task under a contract — async, settled on delivery (EXCHANGE / TARGET-045 Gap 2)
+         * @description The CONSUMER starts a task against an agent-work offering they hold an active contract for. Body: `{ offering_id, input, note? }`. Nothing is charged yet — the per-task price is metered when the provider DELIVERS. Requires a contract first (else 402 NO_CONTRACT). Returns `{ work }`.
+         */
+        post: operations["exchangeStartWork"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/work/{id}/deliver": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Deliver an agent-work task → settle on delivery (EXCHANGE / TARGET-045 Gap 2)
+         * @description The PROVIDER delivers a task and is paid: the consumer is charged the per-task price, the provider is credited its cut, the platform rake is routed, the budget decremented — all ON DELIVERY. Body: `{ output, note? }`. A 402/429 (budget/rate) leaves the work open + unpaid. Returns `{ work }`.
+         */
+        post: operations["exchangeDeliverWork"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * EXCHANGE marketplace economics — the platform rake + units (EXCHANGE / TARGET-045)
+         * @description Public. Returns `{ rake_percent, rake_note, units, morsel_note }` — the platform fee applied to each metered call (the provider keeps the rest), set by the node operator via AIMEAT_COMMERCE_FEE_PERCENT / AIMEAT_MARKETPLACE_TX_FEE_PERCENT.
+         */
+        get: operations["exchangeInfo"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/offerings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Browse listed EXCHANGE offerings (public) — by capability or free text (TARGET-045)
+         * @description Public browse of listed supply. `?ext=&action=` matches a capability exactly; `?q=` free-text over title/description/tags; omit both for all listings. `?stats=1` folds usage/reputation (`stats: { activeContracts, totalContracts, totalCalls, totalSettledUnits, consumers, listedAt, lastUsedAt }`) into each listing. Cheapest base price first. Returns `{ offerings, count }`.
+         */
+        get: operations["exchangeBrowseOfferings"];
+        put?: never;
+        /**
+         * List a supply OFFERING — an ext action or an app-tool you own (EXCHANGE marketplace / TARGET-045)
+         * @description Publish a public supply listing. Two kinds. DEFAULT `kind: ext-action` — a priced action of an extension you own; price + plans read AUTHORITATIVELY from the action (`commercial`); body `{ ext, action, title?, description?, provenance?, usage_terms, tags? }`. `kind: app-tool` — a method your APP sells cross-app (a getCompanyBrief-style tool from your `apps.{appId}.tools` manifest); price + plans read from the tool; the tool MUST be bound to a capability (`action_id`) and is snapshot into an immutable, pinned INTERFACE VERSION (a schema/binding change mints a new version; existing contracts stay pinned to theirs); body `{ kind: 'app-tool', app_id, tool, title?, description?, provenance?, usage_terms, tags? }`. LEGIBILITY GATE (both): a non-empty input AND output schema is required (else 400 SCHEMA_REQUIRED) and `usage_terms` is required (else 400 USAGE_TERMS_REQUIRED). `usage_terms` = `{ derivatives?, resale?, attribution?, note? }`. Returns `{ offering }`.
+         */
+        post: operations["exchangeListOffering"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/offerings/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * 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, 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)
+         * @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;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Provider data-lineage — who holds contracts against your offering (owner only) (TARGET-045)
+         * @description The provider's consumption log: for each contract minted against this offering, the consuming identity, calls served, value settled, state, and last use — "where is my data used, by whom?". Owner-only (a stranger gets 404). Returns `{ offeringId, consumers, count }`.
+         */
+        get: operations["exchangeOfferingConsumers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/needs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Browse EXCHANGE needs — `?open=1` open only, `?mine=1` your own (TARGET-045) */
+        get: operations["exchangeBrowseNeeds"];
+        put?: never;
+        /**
+         * Post an open NEED (demand) providers can bid on (EXCHANGE marketplace / TARGET-045)
+         * @description Publish a demand on behalf of a specific app. `app_id` is REQUIRED (a need is always app-bound). Body: `{ description, app_id, ext?, action?, spec?, usage_intent?, budget_unit?, budget_cap?, autonomy? }`. `spec` = `{ requiredFields?, format?, sample?, notes? }` — the minimum shape a fulfilment must return, so a provider (or an AI assessing candidates) can judge fit. Returns `{ need, matches }` (offerings already satisfying it, so you can accept directly).
+         */
+        post: operations["exchangePostNeed"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/needs/{id}/close": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Close one of your EXCHANGE needs (TARGET-045) */
+        post: operations["exchangeCloseNeed"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/needs/{id}/bids": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List bids on a NEED (public) (TARGET-045) */
+        get: operations["exchangeListBids"];
+        put?: never;
+        /**
+         * Bid on an open NEED with an action your extension owns (EXCHANGE / TARGET-045)
+         * @description Body: `{ ext, action, offering_id?, plan_id?, note? }`. Returns `{ bid }`.
+         */
+        post: operations["exchangeBidOnNeed"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/exchange/needs/{id}/bids/{bidId}/accept": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Accept a bid on your NEED → mint the metered entitlement (EXCHANGE / TARGET-045)
+         * @description The requester accepts a bid; mints the durable entitlement (consumer = you, provider = bidder), with the bid's plan + authoritative price. Optional body `{ cap_units }` overrides the need's budget cap. Marks the bid accepted + the need matched. Returns `{ entitlement_id, ext, action, unit, pricing }`.
+         */
+        post: operations["exchangeAcceptBid"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/ledger/billing": {
         parameters: {
             query?: never;
@@ -2721,6 +3385,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;
@@ -3913,6 +4579,50 @@ 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) to a connected account through a provider that holds the funds, while **x402** settles a stablecoin on-chain straight to an address you control, non-custodially, with the node holding no key. Returns `{ x402: { enabled, network, testnet, configured, address, currencies, assets, note }, stripe: { configured, provider, 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/checkout-sessions": {
         parameters: {
             query?: never;
@@ -5502,7 +6212,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.
@@ -5549,6 +6268,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;
@@ -6483,6 +7233,9 @@ export interface paths {
          * @description Register a new human owner via the web portal. Creates an owner record,
          *     GHII, and profile. No authentication required. If email is provided,
          *     a verification code is sent and the response includes a verificationId.
+         *     When the node's email gate is on (`AIMEAT_EMAIL_CONFIRMATION_REQUIRED`),
+         *     an email is REQUIRED (missing → `400 EMAIL_REQUIRED`); an email already
+         *     verified on another account → `409 EMAIL_TAKEN`.
          */
         post: operations["ghiiRegisterWeb"];
         delete?: never;
@@ -8036,7 +8789,14 @@ export interface paths {
          *     emit code — a caller wanting an extra button uses `link` (navigation carries no authority).
          */
         post: operations["createNotification"];
-        delete?: never;
+        /**
+         * Clear the caller's notifications (the bell's "Clear all")
+         * @description Delete the caller's in-app notifications — the header bell's "Clear all". Unlike
+         *     POST /v1/notifications/read (which only marks them read), this REMOVES the rows. Owner-scoped:
+         *     only the caller's own notifications are affected. Omit the body (or send `{}`) to clear ALL;
+         *     pass `{ ids: [...] }` to delete just those.
+         */
+        delete: operations["clearNotifications"];
         options?: never;
         head?: never;
         patch?: never;
@@ -10561,14 +11321,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;
@@ -15417,6 +16186,12 @@ export interface paths {
          *     username or a full `username@node-id` (the node part must match this node). The first
          *     real owner is auto-granted the `operator` role. Returns the owner keypair once —
          *     the private key is never retrievable again. A welcome morsel bonus is granted.
+         *
+         *     When an `email` is supplied it is recorded and a verification code is sent (confirm via
+         *     `POST /v1/ghii/verify-email`); a `verification_id` is returned. When the node runs with the
+         *     email gate on (`AIMEAT_EMAIL_CONFIRMATION_REQUIRED`), an email is REQUIRED — registering
+         *     without one → `400 EMAIL_REQUIRED` (OAuth sign-in satisfies the gate, its IdP email being
+         *     verified at that instant). An email already verified on another account → `409 EMAIL_TAKEN`.
          */
         post: operations["registerGhii"];
         /**
@@ -16978,6 +17753,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;
@@ -18354,6 +19135,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;
@@ -18371,6 +19177,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"];
@@ -20285,6 +21092,97 @@ export interface operations {
             };
         };
     };
+    unfurlLink: {
+        parameters: {
+            query: {
+                /** @description The http(s) URL to unfurl. */
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Preview metadata */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            url?: string;
+                            resolvedUrl?: string;
+                            title?: string | null;
+                            description?: string | null;
+                            /** @description Absolute image URL; fetch it via /v1/unfurl/image (the SPA CSP forbids remote image hosts). */
+                            image?: string | null;
+                            siteName?: string | null;
+                        };
+                    };
+                };
+            };
+            /** @description Missing or non-http(s) url parameter */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The link could not be fetched (blocked by the SSRF guard, timeout, or network error) */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    unfurlImage: {
+        parameters: {
+            query: {
+                /** @description The http(s) image URL to proxy. */
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The image bytes */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "image/*": string;
+                };
+            };
+            /** @description Missing or non-http(s) url parameter */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The URL did not resolve to an image */
+            415: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The image could not be fetched (blocked, timeout, or network error) */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     validateRequest: {
         parameters: {
             query?: never;
@@ -20954,7 +21852,14 @@ export interface operations {
         requestBody: {
             content: {
                 "application/json": {
-                    /** @description Owner name */
+                    /**
+                     * @description The target account: either the account HANDLE (e.g. `alice`) or the account's
+                     *     VERIFIED email address (case-insensitive). A value containing `@` is resolved as an
+                     *     email to the owning account's handle. No account with that verified email → 404
+                     *     `NO_ACCOUNT`; malformed email → 400 `INVALID_EMAIL`; (should-never-happen) more than
+                     *     one match → 409 `AMBIGUOUS`. The value only SELECTS which account this request targets
+                     *     — it is not an authentication factor (the human still approves the device code).
+                     */
                     owner: string;
                     /** @description Agent name (3-32 chars, lowercase alphanumeric + hyphens) */
                     agent_name: string;
@@ -20997,6 +21902,20 @@ export interface operations {
                 };
             };
             400: components["responses"]["BadRequest"];
+            /** @description `owner` was an email with no matching verified account (NO_ACCOUNT) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description `owner` email maps to more than one account (AMBIGUOUS — invariant violation) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Too many pending requests for this owner */
             429: {
                 headers: {
@@ -22130,6 +23049,27 @@ export interface operations {
             };
         };
     };
+    getAppdevFlowPrompt: {
+        parameters: {
+            query?: {
+                /** @description txt returns the prompt as text/plain instead of the JSON envelope */
+                format?: "txt";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The flow prompt (JSON envelope, or text/plain with format=txt) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     listLibraryPacks: {
         parameters: {
             query?: {
@@ -22248,6 +23188,240 @@ export interface operations {
             };
         };
     };
+    getAppdevOverview: {
+        parameters: {
+            query?: {
+                model?: string;
+                /** @description Comma-separated subset of apps,library_packs,app_templates,skills,pitfalls_curated,pitfalls_learned,template_proposals */
+                sections?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The overview sections (indexes + drill-down pointers) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    listLearnedAppdevPitfalls: {
+        parameters: {
+            query?: {
+                include_shared?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description data.pitfalls (full bodies) + data.total */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    deleteLearnedAppdevPitfall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                category: string;
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description data.deleted = true */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such learned pitfall in the caller's scope */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    updateLearnedAppdevPitfall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                category: string;
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description true = public (platform-wide) */
+                    share?: boolean;
+                    /** @enum {string} */
+                    status?: "active" | "outdated";
+                };
+            };
+        };
+        responses: {
+            /** @description The updated entry (data.pitfall) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            /** @description No such learned pitfall in the caller's scope */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listAppdevTemplateProposals: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description data.templates + data.total */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getAppdevTemplateProposal: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description data.template + data.source_app */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such template proposal */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    deleteAppdevTemplateProposal: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description data.deleted = true */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such template proposal */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listAppdevPitfalls: {
+        parameters: {
+            query?: {
+                applies_to?: "app" | "auth" | "ext" | "cortex" | "iam" | "realtime" | "ai" | "mobile" | "publish";
+                severity?: "info" | "warn" | "critical";
+                limit?: number;
+                offset?: number;
+                include_outdated?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Paginated pitfall index (data.pitfalls, data.total, data.facets) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getAppdevPitfall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The pitfall entry (data.pitfall) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such pitfall */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     listMemory: {
         parameters: {
             query?: {
@@ -22837,6 +24011,618 @@ export interface operations {
             403: components["responses"]["AimeatError"];
         };
     };
+    appCost: {
+        parameters: {
+            query: {
+                /** @description App id ("owner/filename") whose sourcing cost & contracts to return. */
+                app_id: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeListEntitlements: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeAcceptContract: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Preferred — contract an offering by id (ext-action or app-tool). Pins the app-tool interface version. */
+                    offering_id?: string;
+                    /** @description Legacy path — raw ext-action; required with action + contract_ref when offering_id is omitted. */
+                    ext?: string;
+                    action?: string;
+                    contract_ref?: string;
+                    /** @description Spend cap in the price unit (morsels */
+                    cap_units?: number;
+                    /** @description Consuming app id ("owner/filename") for the per-app cost surface. */
+                    app_id?: string;
+                    /** @enum {string} */
+                    escrow_party?: "consumer" | "provider";
+                    /** @description Optional provider pricing plan (bundle / subscription); omit for per-call at the base price. */
+                    plan_id?: string;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            401: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeEntitlementOff: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    ext: string;
+                    action: string;
+                    /**
+                     * @default pause
+                     * @enum {string}
+                     */
+                    mode?: "pause" | "revoke";
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeListProposals: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeProposeChange: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    ext: string;
+                    action: string;
+                    /** @description Provider-side: the consumer whose contract to renegotiate. Omit when you are the consumer. */
+                    consumer_gaii?: string;
+                    /** @description New per-call price in the contract's unit (morsels, or money micro-units). Omit to leave unchanged. */
+                    new_price_per_call?: number;
+                    /** @description New budget cap. Omit to leave unchanged. */
+                    new_cap_units?: number;
+                    note?: string;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeAcceptProposal: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+            409: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeDeclineProposal: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeWithdrawProposal: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeEntitlementHistory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeProviderHistory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeListWork: {
+        parameters: {
+            query?: {
+                role?: "consumer" | "provider";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeStartWork: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    offering_id: string;
+                    input?: unknown;
+                    note?: string;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            402: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeDeliverWork: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    output?: unknown;
+                    note?: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            402: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+            409: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeInfo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeBrowseOfferings: {
+        parameters: {
+            query?: {
+                ext?: string;
+                action?: string;
+                q?: string;
+                stats?: "1";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeListOffering: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * @default ext-action
+                     * @enum {string}
+                     */
+                    kind?: "ext-action" | "app-tool" | "agent-work";
+                    /** @description ext-action kind — the extension name. */
+                    ext?: string;
+                    /** @description ext-action kind — the action id. */
+                    action?: string;
+                    /** @description app-tool kind — the app filename whose manifest holds the tool. */
+                    app_id?: string;
+                    /** @description app-tool kind — the tool name in apps.{app_id}.tools. */
+                    tool?: string;
+                    /** @description agent-work kind — your agent that performs the task. */
+                    agent_name?: string;
+                    /** @description agent-work kind — the task type it performs. */
+                    task_type?: string;
+                    /** @description agent-work kind — what the consumer sends (required). */
+                    input_schema?: Record<string, never>;
+                    /** @description agent-work kind — what the agent delivers (required). */
+                    output_schema?: Record<string, never>;
+                    /** @description agent-work kind — per-task morsel price. */
+                    price_morsels?: number;
+                    /** @description agent-work kind — per-task money price { amount (micros), currency }. */
+                    price_money?: Record<string, never>;
+                    /** @description agent-work kind — optional bundle/subscription plans. */
+                    plans?: Record<string, never>[];
+                    title?: string;
+                    description?: string;
+                    /** @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;
+                        resale?: boolean;
+                        attribution?: boolean;
+                        note?: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeOfferingDetail: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeDelistOffering: {
+        parameters: {
+            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;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            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;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeBrowseNeeds: {
+        parameters: {
+            query?: {
+                open?: string;
+                mine?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangePostNeed: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    description: string;
+                    /** @description REQUIRED — the requesting app (owner/filename). A need is always posted on behalf of the app that needs the data. */
+                    app_id: string;
+                    ext?: string;
+                    action?: string;
+                    /** @description The interface the app is waiting to call. */
+                    spec?: {
+                        requiredFields?: string[];
+                        format?: string;
+                        sample?: string;
+                        notes?: string;
+                        /** @description The shape the app will SEND on each call. */
+                        inputSchema?: Record<string, never>;
+                        /** @description The shape the app EXPECTS back (a provider builds a matching app-tool). */
+                        outputSchema?: Record<string, never>;
+                    };
+                    /** @description How the requester will USE the data — lets a provider judge before serving. */
+                    usage_intent?: string;
+                    /** @enum {string} */
+                    budget_unit?: "money" | "morsels";
+                    budget_cap?: number;
+                    /** @enum {string} */
+                    autonomy?: "supervised" | "auto";
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeCloseNeed: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeListBids: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    exchangeBidOnNeed: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    ext: string;
+                    action: string;
+                    offering_id?: string;
+                    plan_id?: string;
+                    note?: string;
+                };
+            };
+        };
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+            409: components["responses"]["AimeatError"];
+        };
+    };
+    exchangeAcceptBid: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                bidId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            201: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["AimeatError"];
+            404: components["responses"]["AimeatError"];
+        };
+    };
     ledgerBilling: {
         parameters: {
             query?: {
@@ -25456,6 +27242,53 @@ 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"];
+        };
+    };
     listCheckoutSessions: {
         parameters: {
             query?: {
@@ -28144,6 +29977,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;
@@ -28280,6 +30155,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;
@@ -33272,6 +35203,32 @@ export interface operations {
             };
         };
     };
+    clearNotifications: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Notification ids to clear (omit to clear all) */
+                    ids?: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Count cleared ({ cleared }) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
     markNotificationsRead: {
         parameters: {
             query?: never;
@@ -35237,12 +37194,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;
                 };
             };
         };
@@ -37111,10 +39083,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;
@@ -37123,12 +39098,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"];
@@ -39810,6 +41803,7 @@ export interface operations {
                         /** @default false */
                         done?: boolean;
                     }[];
+                    resources?: components["schemas"]["AgentTaskResources"];
                 };
             };
         };
@@ -46729,6 +48723,11 @@ export interface operations {
                     locale?: string;
                     /** @description Optional; min 8 chars */
                     password?: string;
+                    /**
+                     * Format: email
+                     * @description Optional; REQUIRED when the email gate is on. Recorded + a verification code sent.
+                     */
+                    email?: string;
                 };
             };
         };
@@ -46755,6 +48754,10 @@ export interface operations {
                                 name?: string;
                                 roles?: string[];
                             };
+                            /** @description Present when an email was supplied; confirm it via POST /v1/ghii/verify-email */
+                            verification_id?: string | null;
+                            /** @description Whether a verification email was dispatched (email service must be enabled) */
+                            email_sent?: boolean;
                             private_key?: string;
                             public_key?: string;
                             has_password?: boolean;
@@ -46763,8 +48766,20 @@ export interface operations {
                     };
                 };
             };
-            400: components["responses"]["BadRequest"];
-            409: components["responses"]["Conflict"];
+            /** @description Invalid input, or EMAIL_REQUIRED when the node's email gate is on and no email was supplied */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description NAME_TAKEN, or EMAIL_TAKEN when the email is already verified on another account */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     deleteGhii: {