@runtypelabs/sdk 10.8.1 → 10.9.0

package/dist/index.d.cts

@@ -1480,6 +1480,8 @@ interface paths {
       requestBody?: {
         content: {
           "application/json": {
+            /** @description The complete set of capabilities (flow, sub-agent and saved-tool attachments) on this agent, in display order. Each entry names its source by name, so the declaration is portable across accounts. Capabilities on the agent but absent here are removed; omit the field to leave them untouched. When present, the capabilities are part of the content hash and of the version this converge snapshots. They are written to the agent itself, so they cannot accompany a non-live deploy. */
+            capabilities?: components["schemas"]["AgentEnsureCapability"][];
             contentHash?: string;
             definition?: {
               config?: {
@@ -1790,6 +1792,8 @@ interface paths {
              * @enum {string}
              */
             release?: "none" | "publish";
+            /** @description The complete set of skills bound to this agent, in load order. Each entry names a skill by slug; `version` pins that skill versionNumber, and omitting it follows the skill's published version. Skills bound to the agent but absent here are unbound; omit the field to leave bindings untouched. Bindings are agent state, not alias state, so they take effect immediately and cannot accompany a non-live deploy. */
+            skills?: components["schemas"]["AgentEnsureSkillBinding"][];
             version?: components["schemas"]["EnsureVersionMetadata"];
           };
         };
@@ -10544,6 +10548,8 @@ interface paths {
                 icon: string | null;
                 id: string;
                 indexedFields: string[];
+                /** @description Who last wrote the definition (e.g. dashboard, api, sdk); sdk/terraform mean managed in code. */
+                lastModifiedSource: string | null;
                 recordCount?: number;
                 /** @description Constrained JSON Schema dialect: root object with string/number/boolean/array/object properties, one nesting level, no $ref/oneOf/pattern */
                 schema: {
@@ -10642,6 +10648,8 @@ interface paths {
               icon: string | null;
               id: string;
               indexedFields: string[];
+              /** @description Who last wrote the definition (e.g. dashboard, api, sdk); sdk/terraform mean managed in code. */
+              lastModifiedSource: string | null;
               recordCount?: number;
               /** @description Constrained JSON Schema dialect: root object with string/number/boolean/array/object properties, one nesting level, no $ref/oneOf/pattern */
               schema: {
@@ -10712,6 +10720,125 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/collections/ensure": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Ensure collection (config-as-code converge)
+     * @description Idempotently converge a repo-defined record collection (display fields, schema and validationMode) onto the platform. Identity is slug + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response); full requests create the collection or update it when the canonical content hash differs. Schema changes follow the same rules as PATCH: they bump schemaVersion and append history, and a breaking change is rejected while the resulting mode is `enforce`. Set dryRun to plan without writing (CI drift gate), and onConflict: "overwrite" to converge over dashboard/API edits. Ensure never deletes a collection and never touches records.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          "application/json": {
+            contentHash?: string;
+            definition?: {
+              description?: string | null;
+              displayName: string;
+              icon?: string | null;
+              /** @description Constrained JSON Schema dialect: root object with string/number/boolean/array/object properties, one nesting level, no $ref/oneOf/pattern */
+              schema?: {
+                [key: string]: unknown;
+              } | null;
+              slug: string;
+              /** @enum {string} */
+              validationMode?: "off" | "warn" | "enforce";
+            };
+            dryRun?: boolean;
+            expectedRemoteHash?: string;
+            /** @enum {string} */
+            onConflict?: "error" | "overwrite";
+            slug: string;
+          };
+        };
+      };
+      responses: {
+        /** @description Converge result: unchanged | created | updated | definitionRequired (hash miss — retry with the full definition) | plan (dryRun) */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["CollectionEnsureResponse"];
+          };
+        };
+        /** @description Invalid slug or schema, or a breaking schema change while enforcing (BREAKING_SCHEMA_CHANGE_REQUIRES_WARN_MODE) */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"] & {
+              code?: string;
+              details?: unknown;
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Insufficient permissions */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Conflict: external_modification (last write was not ensure; pass onConflict: "overwrite") or remote_changed (expectedRemoteHash guard) */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["CollectionEnsureConflict"];
+          };
+        };
+        /** @description Submitted contentHash does not match the server-recomputed canonical hash */
+        422: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["CollectionEnsureHashMismatch"];
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/collections/types.d.ts": {
     parameters: {
       query?: never;
@@ -10826,6 +10953,8 @@ interface paths {
               icon: string | null;
               id: string;
               indexedFields: string[];
+              /** @description Who last wrote the definition (e.g. dashboard, api, sdk); sdk/terraform mean managed in code. */
+              lastModifiedSource: string | null;
               recordCount?: number;
               /** @description Constrained JSON Schema dialect: root object with string/number/boolean/array/object properties, one nesting level, no $ref/oneOf/pattern */
               schema: {
@@ -10989,6 +11118,8 @@ interface paths {
                 icon: string | null;
                 id: string;
                 indexedFields: string[];
+                /** @description Who last wrote the definition (e.g. dashboard, api, sdk); sdk/terraform mean managed in code. */
+                lastModifiedSource: string | null;
                 recordCount?: number;
                 /** @description Constrained JSON Schema dialect: root object with string/number/boolean/array/object properties, one nesting level, no $ref/oneOf/pattern */
                 schema: {
@@ -11158,6 +11289,83 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/collections/{slug}/pull": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Pull collection definition (config-as-code)
+     * @description Return the canonical config-as-code definition and provenance for a collection — the absorb-drift direction of the ensure protocol. The contentHash is recomputed from the live collection, so it is accurate even immediately after a dashboard edit.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          slug: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Canonical definition + provenance */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["CollectionPullResponse"];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Insufficient permissions */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description No collection with that slug in the account scope */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/collections/{slug}/validate-existing": {
     parameters: {
       query?: never;
@@ -15806,7 +16014,7 @@ interface paths {
     put?: never;
     /**
      * Ensure eval suite (config-as-code converge)
-     * @description Idempotently converge a repo-defined eval suite (target + cases + graders) onto the platform. Identity is the suite name + account scope; the target flow/agent is resolved by name. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the suite or replace its cases when the canonical content hash differs. Non-executing: never runs the eval. The response always carries the server-computed canonical hash.
+     * @description Idempotently converge a repo-defined eval suite (target + cases + graders) onto the platform. Identity is the suite name + account scope; the target flow/agent is resolved by name. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the suite or replace the cases ensure owns when the canonical content hash differs. Cases saved from runs, added in the dashboard, or owned by a product are never replaced. Set dryRun to plan without writing (CI drift gate), and onConflict: "overwrite" to converge over dashboard/API edits. Non-executing: never runs the eval. The response always carries the server-computed canonical hash.
      */
     post: {
       parameters: {
@@ -15870,12 +16078,16 @@ interface paths {
               };
               virtual?: boolean;
             };
+            dryRun?: boolean;
+            expectedRemoteHash?: string;
             name: string;
+            /** @enum {string} */
+            onConflict?: "error" | "overwrite";
           };
         };
       };
       responses: {
-        /** @description Converge result: unchanged | created | updated | definitionRequired (hash miss — retry with the full definition) */
+        /** @description Converge result: unchanged | created | updated | definitionRequired (hash miss — retry with the full definition) | plan (dryRun) */
         200: {
           headers: {
             [name: string]: unknown;
@@ -15911,6 +16123,15 @@ interface paths {
             "application/json": components["schemas"]["Error"];
           };
         };
+        /** @description Conflict: external_modification (last write was not ensure; pass onConflict: "overwrite") or remote_changed (expectedRemoteHash guard) */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["EvalEnsureConflict"];
+          };
+        };
         /** @description Submitted contentHash does not match the server-recomputed canonical hash */
         422: {
           headers: {
@@ -16195,7 +16416,7 @@ interface paths {
     };
     /**
      * Pull eval suite definition (config-as-code)
-     * @description Return the canonical config-as-code definition and provenance for an eval suite by name — the absorb-drift direction of the ensure protocol. The contentHash is recomputed from the live suite state.
+     * @description Return the canonical config-as-code definition and provenance for an eval suite by name — the absorb-drift direction of the ensure protocol. The definition carries the cases ensure owns (or, for a suite ensure never wrote, its unowned cases), and the contentHash is recomputed from that live state.
      */
     get: {
       parameters: {
@@ -16935,7 +17156,7 @@ interface paths {
               name: string;
               notes?: string;
               /**
-               * @description Case provenance. Defaults to "manual" when omitted.
+               * @description Case provenance. Defaults to "manual" when omitted. "ensure" is reserved for config-as-code converges.
                * @enum {string}
                */
               origin?: "manual" | "saved_from_run" | "generated" | "imported" | "fpo";
@@ -17341,7 +17562,7 @@ interface paths {
               name: string;
               notes?: string;
               /**
-               * @description Case provenance. Defaults to "manual" when omitted.
+               * @description Case provenance. Defaults to "manual" when omitted. "ensure" is reserved for config-as-code converges.
                * @enum {string}
                */
               origin?: "manual" | "saved_from_run" | "generated" | "imported" | "fpo";
@@ -18848,6 +19069,10 @@ interface paths {
               executionLane?: "durable" | "in_process";
               httpStatus?: number;
               result?: unknown;
+              /** @description Present and `true` when the execution settled but its result was too large to store or could not be retrieved; `result` then holds only a summary and `resultUnavailableReason` explains why. `error` keeps describing an execution failure; on an otherwise completed execution it repeats the reason. */
+              resultUnavailable?: boolean;
+              /** @description Why the result is unavailable. Present exactly when `resultUnavailable` is `true`. */
+              resultUnavailableReason?: string;
               /** @enum {string} */
               status: "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
               targetId?: string;
@@ -30707,6 +30932,7 @@ interface paths {
                 productGoal?: string;
                 /** @enum {string} */
                 productStage?: "idea" | "prototype" | "beta" | "production" | "scaling";
+                stack?: components["schemas"]["ProductStack"];
                 targetAudience?: string;
                 techStack?: {
                   backend?: string[];
@@ -30808,7 +31034,7 @@ interface paths {
     put?: never;
     /**
      * Ensure full product (config-as-code converge of the whole FPO)
-     * @description Idempotently converge an entire Full Product Object (the nested product graph) in one shot. Fans out to the per-entity ensure services in dependency order (product → capability backing flows/agents → capability-as-tool composition → capability links → surfaces + surface items → records → schedules → secret bindings), returning a per-entity report. Identity is the product name + account scope. NON-atomic by design: a per-entity failure is reported in `entities[].result = "failed"` (and `hasFailures`) and a re-run self-heals; only a top-level product reject aborts. Set dryRun to plan without writing. Set prune to remove product-scoped capabilities/surfaces (and their items) absent from the FPO (account-scoped flows/agents/tools/records are never removed). Whole-FPO fast-probe is not yet supported (PR3). API keys converge each nested flow, agent, schedule, record, eval suite and skill only with that entity kind's own write scope (FLOWS:WRITE, AGENTS:WRITE or AGENTS:CREATE/UPDATE, SCHEDULES:WRITE, RECORDS:WRITE, EVALS:WRITE, SKILLS:WRITE) on top of the product scope; otherwise that entity reports `failed`. Binding a skill to an agent also needs agent update scope. Schedules also honor the plan's active-schedule limit and minimum frequency.
+     * @description Idempotently converge an entire Full Product Object (the nested product graph) in one shot. Fans out to the per-entity ensure services in dependency order (product → capability backing flows/agents → capability-as-tool composition → capability links → surfaces + surface items → records → schedules → secret bindings), returning a per-entity report. Identity is the product name + account scope. NON-atomic by design: a per-entity failure is reported in `entities[].result = "failed"` (and `hasFailures`) and a re-run self-heals; only a top-level product reject aborts. Converged capability agents and flows are published to `live` by default; set release to "none" to save changes as drafts. Set dryRun to plan without writing. Set prune to remove product-scoped capabilities/surfaces (and their items) absent from the FPO (account-scoped flows/agents/tools/records are never removed). A hash-only probe (`name` + `contentHash`, no fpo) with release "none" answers `unchanged` when the live graph reconstructs (as GET /products/pull-fpo does) to that hash, else `definitionRequired` (retry with the full fpo); a probe that publishes (the default release) always answers `definitionRequired`, because only a full converge can publish drafts that are not yet live. The probe, the dryRun `remoteHash` and expectedRemoteHash read the live graph, so API keys need PRODUCTS:READ for them. A dryRun reports the live graph's `remoteHash`; pass it as expectedRemoteHash on the apply to refuse the write (409 remote_changed) if the product changed in between. The guard compares what GET /products/pull-fpo reconstructs, so edits to seed records, schedules or secrets (which pull-fpo omits) do not trip it. When pull-fpo has to omit part of the product (a capability, surface, schedule, eval suite or skill it cannot represent), a probe answers `definitionRequired`, a dryRun reports no `remoteHash`, and expectedRemoteHash is refused with 409. The guard is re-checked immediately before the first write but does not lock the graph, so an edit that lands while the apply is running can still be overwritten. API keys need PRODUCTS:CREATE to create the product and PRODUCTS:UPDATE to change an existing one (PRODUCTS:WRITE covers both). API keys converge each nested flow, agent, tool, surface, schedule, record, eval suite and skill only with that entity kind's own write scope (FLOWS:WRITE, AGENTS:WRITE or AGENTS:CREATE/UPDATE, TOOLS:WRITE, PRODUCTS:SURFACES:WRITE, SCHEDULES:WRITE, RECORDS:WRITE, EVALS:WRITE, SKILLS:WRITE) on top of the product scope; otherwise that entity reports `failed`. Adding or changing a capability on an existing product needs PRODUCTS:CAPABILITIES:WRITE, and adding a route to an existing surface needs PRODUCTS:SURFACES:WRITE. Prune needs PRODUCTS:CAPABILITIES:WRITE to remove capabilities and PRODUCTS:SURFACES:WRITE to remove surfaces or their items, and a pruned surface's client tokens are revoked. Binding a skill to an agent also needs agent update scope. Schedules also honor the plan's active-schedule limit and minimum frequency.
      */
     post: {
       parameters: {
@@ -30820,12 +31046,18 @@ interface paths {
       requestBody?: {
         content: {
           "application/json": {
+            /** @description Hash-only probe: the canonical FPO hash the caller holds. Answers `unchanged` when the live graph reconstructs (as pull-fpo does) to this hash, else `definitionRequired`. Only valid without `fpo`. */
+            contentHash?: string;
             /** @description Plan without writing — returns a per-entity plan (CI drift gate). */
             dryRun?: boolean;
-            /** @description A complete Full Product Object (FPO): the nested product graph (product, capabilities, tools, surfaces, ...). Validated server-side via the shared FPO validator. */
-            fpo: {
+            /** @description TOCTOU guard binding a dry run to its apply: the write proceeds only while the live graph still hashes to this value (the dry run's `remoteHash`); otherwise 409 remote_changed. */
+            expectedRemoteHash?: string;
+            /** @description A complete Full Product Object (FPO): the nested product graph (product, capabilities, tools, surfaces, ...). Validated server-side via the shared FPO validator. Omit it only for a hash-only probe (`name` + `contentHash`). */
+            fpo?: {
               [key: string]: unknown;
             };
+            /** @description The product name a hash-only probe resolves. Only valid without `fpo`. */
+            name?: string;
             /**
              * @description Per nested entity: "overwrite" converges over dashboard/API edits.
              * @enum {string}
@@ -30833,11 +31065,16 @@ interface paths {
             onConflict?: "error" | "overwrite";
             /** @description Opt-in removal of product-scoped capabilities/surfaces (and their items) absent from the FPO, after the converge passes. NEVER touches account-scoped flows/agents/tools/records. Honors createPolicy:"skip". With dryRun, reports would-be removals as `pruned` plan rows. */
             prune?: boolean;
+            /**
+             * @description Whether converged capability agents and flows go live. Defaults to "publish": an agent or flow whose converged content is not yet live is versioned and published (the agent's `live` alias moves to that version), matching product creation. "none" saves changes as drafts and leaves `live` where it was. Publishing needs update authority over that entity kind, and for an agent the live deploy scope (AGENTS:DEPLOY:LIVE; AGENTS:WRITE or AGENTS:UPDATE also accepted); an API key without it converges that kind as "none".
+             * @enum {string}
+             */
+            release?: "none" | "publish";
           };
         };
       };
       responses: {
-        /** @description Converge result: unchanged | converged | plan (dryRun), with a per-entity report. */
+        /** @description Converge result: unchanged | converged | plan (dryRun), with a per-entity report; or definitionRequired (hash-only probe miss — retry with the full fpo). */
         200: {
           headers: {
             [name: string]: unknown;
@@ -30873,7 +31110,7 @@ interface paths {
             "application/json": components["schemas"]["Error"];
           };
         };
-        /** @description Conflict converging the top-level product: external_modification or remote_changed. */
+        /** @description Conflict: external_modification converging the top-level product, or remote_changed (expectedRemoteHash guard). */
         409: {
           headers: {
             [name: string]: unknown;
@@ -33125,7 +33362,7 @@ interface paths {
     put?: never;
     /**
      * Ensure surface (config-as-code converge)
-     * @description Idempotently converge a repo-defined surface definition onto a product. Identity is name + product. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the surface or update it when the canonical content hash differs. The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), and onConflict: "overwrite" to converge over dashboard/API edits. Surfaces have no version snapshots, so there is no publish option.
+     * @description Idempotently converge a repo-defined surface definition onto a product. Identity is name + product. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the surface or update it when the canonical content hash differs. The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), and onConflict: "overwrite" to converge over dashboard/API edits. Surfaces have no version snapshots, so there is no publish option. inbound/outbound are excluded from the content hash, so a request carrying them must send the full definition; changes to them are reported in changedKeys (as inbound.<key> / outbound.<key>) and converge as "updated".
      */
     post: {
       parameters: {
@@ -33146,13 +33383,15 @@ interface paths {
               };
               /** @enum {string} */
               environment?: "production" | "development";
+              /** @description Inbound channel config. Omit to keep the stored value; null clears it. A credential value of "<redacted>" (as returned by pull) keeps the stored credential. */
               inbound?: {
                 [key: string]: unknown;
-              };
+              } | null;
               name: string;
+              /** @description Outbound channel config. Omit to keep the stored value; null clears it. A credential value of "<redacted>" (as returned by pull) keeps the stored credential. */
               outbound?: {
                 [key: string]: unknown;
-              };
+              } | null;
               /** @enum {string} */
               status?: "draft" | "active" | "paused";
               /** @enum {string} */
@@ -33256,7 +33495,7 @@ interface paths {
     };
     /**
      * Pull surface definition (config-as-code)
-     * @description Return the canonical config-as-code definition and provenance for a surface by name within a product — the absorb-drift direction of the ensure protocol. The contentHash is recomputed from the live surface state, so it is accurate even immediately after a dashboard edit.
+     * @description Return the canonical config-as-code definition and provenance for a surface by name within a product — the absorb-drift direction of the ensure protocol. The contentHash is recomputed from the live surface state, so it is accurate even immediately after a dashboard edit. Configured inbound/outbound credentials are returned as the "<redacted>" placeholder, which ensure accepts to keep the stored value; inbound/outbound are null when the surface has none.
      */
     get: {
       parameters: {
@@ -39609,6 +39848,216 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/question-sets/ensure": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Ensure question set (config-as-code converge)
+     * @description Idempotently converge a repo-defined question set. Identity is the slug within the organization. A hash-only probe skips the payload in the steady state (a miss is a normal 200 `definitionRequired`, not an error); a full request creates the set, or appends a draft version when the questions, input mapping or model differ. Set dryRun to plan without writing, onConflict: "overwrite" to converge over dashboard or API edits, expectedRemoteHash to bind an apply to its dry run, and release: "publish" to publish the latest version. Ensure never deletes a set or a version.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          "application/json": {
+            contentHash?: string;
+            definition?: {
+              description?: string | null;
+              inputMapping?: {
+                [key: string]: string;
+              } | null;
+              model?: string | null;
+              name: string;
+              /** @description Judgment questions keyed by question id, validated like `POST /v1/question-sets`. */
+              questions: {
+                [key: string]: unknown;
+              };
+            };
+            dryRun?: boolean;
+            expectedRemoteHash?: string;
+            /** @enum {string} */
+            onConflict?: "error" | "overwrite";
+            /** @enum {string} */
+            release?: "none" | "publish";
+            /** @description Identity, unique in the organization: lowercase letters, digits, `-` and `_`, up to 64. */
+            slug: string;
+          };
+        };
+      };
+      responses: {
+        /** @description Converge result: unchanged | created | updated | definitionRequired (hash miss; retry with the full definition) | plan (dryRun) */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetEnsureResponse"];
+          };
+        };
+        /** @description Invalid request or invalid questions */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"] & {
+              code?: string;
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Insufficient permissions, or no organization context */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description The question set was removed while the converge ran */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"] & {
+              code?: string;
+            };
+          };
+        };
+        /** @description Conflict: external_modification (the last write was not ensure; pass onConflict: "overwrite"), remote_changed (expectedRemoteHash guard), or a concurrent write */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetEnsureConflict"];
+          };
+        };
+        /** @description The submitted contentHash does not match the server-recomputed canonical hash */
+        422: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetEnsureHashMismatch"];
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/question-sets/pull": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Pull question set definition (config-as-code)
+     * @description Return the canonical config-as-code definition and provenance for a question set by slug. The definition is the latest version, and the contentHash is recomputed from the live row, so it is accurate right after a dashboard edit.
+     */
+    get: {
+      parameters: {
+        query: {
+          /** @description Identity, unique in the organization: lowercase letters, digits, `-` and `_`, up to 64. */
+          slug: string;
+        };
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Canonical definition and provenance */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetPullResponse"];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Insufficient permissions, or no organization context */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description No question set with that slug in the organization */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/question-sets/{id}": {
     parameters: {
       query?: never;
@@ -40115,87 +40564,99 @@ interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/question-sets/{id}/versions/{versionNumber}/publish": {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    get?: never;
-    put?: never;
-    /**
-     * Publish a question set version
-     * @description Freeze the version and make it the one executions resolve when they name no version. Publishing an already-published version moves the current pointer back to it.
-     */
-    post: {
-      parameters: {
-        query?: never;
-        header?: never;
-        path: {
-          id: string;
-          versionNumber: number;
-        };
-        cookie?: never;
-      };
-      requestBody?: never;
-      responses: {
-        /** @description Published */
-        200: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content: {
-            "application/json": {
-              questionSet: components["schemas"]["QuestionSet"];
-              version: components["schemas"]["QuestionSetVersion"];
-            };
-          };
-        };
-        /** @description Invalid request */
-        400: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content: {
-            "application/json": components["schemas"]["QuestionSetError"];
-          };
-        };
-        /** @description Unauthorized */
-        401: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content: {
-            "application/json": components["schemas"]["Error"];
-          };
-        };
-        /** @description Insufficient permissions, or no organization context */
-        403: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content: {
-            "application/json": components["schemas"]["Error"];
-          };
-        };
-        /** @description Not found */
-        404: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content: {
-            "application/json": components["schemas"]["QuestionSetError"];
-          };
-        };
-      };
-    };
-    delete?: never;
-    options?: never;
-    head?: never;
-    patch?: never;
-    trace?: never;
-  };
+  "/v1/question-sets/{id}/versions/{versionNumber}/publish": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Publish a question set version
+     * @description Freeze the version and make it the one executions resolve when they name no version. Publishing an already-published version moves the current pointer back to it.
+     */
+    post: {
+      parameters: {
+        query?: {
+          /** @description A set managed by code (`lastModifiedSource` is `sdk` or `terraform`) answers 409 `managed_by_code_conflict` unless this is `overwrite`. */
+          onConflict?: "error" | "overwrite";
+        };
+        header?: never;
+        path: {
+          id: string;
+          versionNumber: number;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Published */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": {
+              questionSet: components["schemas"]["QuestionSet"];
+              version: components["schemas"]["QuestionSetVersion"];
+            };
+          };
+        };
+        /** @description Invalid request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetError"];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Insufficient permissions, or no organization context */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetError"];
+          };
+        };
+        /** @description Conflict */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["QuestionSetError"];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/records": {
     parameters: {
       query?: never;
@@ -44027,7 +44488,239 @@ interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/schedules/batch/{batchId}/results": {
+  "/v1/schedules/batch/{batchId}/results": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get results for a batch execution
+     * @description Returns the per-record results for a batch execution.
+     */
+    get: {
+      parameters: {
+        query?: {
+          limit?: string;
+          offset?: string;
+          status?: string;
+        };
+        header?: never;
+        path: {
+          batchId: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Batch results */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": {
+              data: {
+                agentExecutionId: string | null;
+                createdAt: string;
+                durationMs: number | null;
+                error: string | null;
+                executedAt: string | null;
+                /**
+                 * @description Engine that actually executed this record execution ('runtime' | 'legacy' | 'external'). Recorded at write time from the committed lane decision; never inferred later. 'external' marks a run a customer executed outside Runtype and reported through ingest. Null for rows written before attribution shipped and for units that never started executing.
+                 * @enum {string|null}
+                 */
+                executionEngine?: "runtime" | "legacy" | "external" | null;
+                failedAt: string | null;
+                failedStepCount: number | null;
+                flowId: string | null;
+                flowName: string | null;
+                record: {
+                  id: string;
+                  name: string;
+                  type: string;
+                } | null;
+                recordId: string;
+                recordResultId: string | null;
+                result?: unknown;
+                status: string;
+                stepCount: number | null;
+              }[];
+              pagination: {
+                hasMore: boolean;
+                limit: number;
+                offset: number;
+                total: number;
+              };
+              summary?: {
+                recordsWithFailedSteps: number;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Insufficient permissions */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Batch not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/schedules/ensure": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Ensure schedule (config-as-code converge)
+     * @description Idempotently converge a repo-defined schedule on a standalone flow or agent. Identity is name + target + account scope; the target may name the flow or agent instead of carrying its id, so one definition works in every environment. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response); full requests create the schedule or update it when the canonical content hash differs. Set dryRun to plan without writing (CI drift gate) and onConflict: "overwrite" to converge over dashboard/API edits. Omit `enabled` to leave a paused schedule paused. Ensure never deletes; schedules owned by a product surface are never matched.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          "application/json": {
+            contentHash?: string;
+            definition?: components["schemas"]["ScheduleEnsureDefinition"];
+            dryRun?: boolean;
+            expectedRemoteHash?: string;
+            name: string;
+            /** @enum {string} */
+            onConflict?: "error" | "overwrite";
+            target: components["schemas"]["ScheduleEnsureTarget"];
+          };
+        };
+      };
+      responses: {
+        /** @description Converge result: unchanged | created | updated | definitionRequired (hash miss — retry with the full definition) | plan (dryRun) */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ScheduleEnsureResponse"];
+          };
+        };
+        /** @description Validation error */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Plan limit exceeded (cron frequency or active schedule count) */
+        402: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ScheduleEntitlementError"];
+          };
+        };
+        /** @description Insufficient permissions */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Target not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+        /** @description Conflict: external_modification (last write was not ensure; pass onConflict: "overwrite") or remote_changed (expectedRemoteHash guard) */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ScheduleEnsureConflict"];
+          };
+        };
+        /** @description Submitted contentHash does not match the server-recomputed canonical hash */
+        422: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ScheduleEnsureHashMismatch"];
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/schedules/pull": {
     parameters: {
       query?: never;
       header?: never;
@@ -44035,67 +44728,40 @@ interface paths {
       cookie?: never;
     };
     /**
-     * Get results for a batch execution
-     * @description Returns the per-record results for a batch execution.
+     * Pull schedule definition (config-as-code)
+     * @description Return the canonical config-as-code definition and provenance for a standalone schedule by name and target — the absorb-drift direction of the ensure protocol. The target is echoed in the form the query used, and the definition always declares `enabled`.
      */
     get: {
       parameters: {
-        query?: {
-          limit?: string;
-          offset?: string;
-          status?: string;
+        query: {
+          name: string;
+          flowId?: string;
+          agentId?: string;
+          flowName?: string;
+          agentName?: string;
         };
         header?: never;
-        path: {
-          batchId: string;
-        };
+        path?: never;
         cookie?: never;
       };
       requestBody?: never;
       responses: {
-        /** @description Batch results */
+        /** @description Canonical definition + provenance */
         200: {
           headers: {
             [name: string]: unknown;
           };
           content: {
-            "application/json": {
-              data: {
-                agentExecutionId: string | null;
-                createdAt: string;
-                durationMs: number | null;
-                error: string | null;
-                executedAt: string | null;
-                /**
-                 * @description Engine that actually executed this record execution ('runtime' | 'legacy' | 'external'). Recorded at write time from the committed lane decision; never inferred later. 'external' marks a run a customer executed outside Runtype and reported through ingest. Null for rows written before attribution shipped and for units that never started executing.
-                 * @enum {string|null}
-                 */
-                executionEngine?: "runtime" | "legacy" | "external" | null;
-                failedAt: string | null;
-                failedStepCount: number | null;
-                flowId: string | null;
-                flowName: string | null;
-                record: {
-                  id: string;
-                  name: string;
-                  type: string;
-                } | null;
-                recordId: string;
-                recordResultId: string | null;
-                result?: unknown;
-                status: string;
-                stepCount: number | null;
-              }[];
-              pagination: {
-                hasMore: boolean;
-                limit: number;
-                offset: number;
-                total: number;
-              };
-              summary?: {
-                recordsWithFailedSteps: number;
-              };
-            };
+            "application/json": components["schemas"]["SchedulePullResponse"];
+          };
+        };
+        /** @description Validation error */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
           };
         };
         /** @description Unauthorized */
@@ -44116,7 +44782,7 @@ interface paths {
             "application/json": components["schemas"]["Error"];
           };
         };
-        /** @description Batch not found */
+        /** @description No schedule with that name on that target in the account scope */
         404: {
           headers: {
             [name: string]: unknown;
@@ -44125,6 +44791,15 @@ interface paths {
             "application/json": components["schemas"]["Error"];
           };
         };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["Error"];
+          };
+        };
       };
     };
     put?: never;
@@ -46523,7 +47198,7 @@ interface paths {
     put?: never;
     /**
      * Ensure skill (config-as-code converge)
-     * @description Idempotently converge a repo-defined skill (SKILL.md manifest) onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the skill or append a new version when the canonical content hash differs. The response always carries the server-computed canonical hash + the version id. Set dryRun to plan without writing (CI drift gate), onConflict: "overwrite" to converge over dashboard/API edits, and release: "publish" to publish the converged version. Admin/control plane only — no review queue.
+     * @description Idempotently converge a repo-defined skill (SKILL.md manifest) onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the skill or append a new version when the canonical content hash differs. The response always carries the server-computed canonical hash + the version id. Set dryRun to plan without writing (CI drift gate), onConflict: "overwrite" to converge over dashboard/API edits, and release: "publish" to publish the converged version. Optional version.label / version.notes stamp provenance (a git SHA, a release tag) on the appended version row. Admin/control plane only — no review queue.
      */
     post: {
       parameters: {
@@ -46550,6 +47225,7 @@ interface paths {
             onConflict?: "error" | "overwrite";
             /** @enum {string} */
             release?: "none" | "publish";
+            version?: components["schemas"]["EnsureVersionMetadata"];
           };
         };
       };
@@ -50684,6 +51360,36 @@ interface components {
       code?: "alias_requires_organization";
       error: string;
     };
+    AgentEnsureCapability: {
+      /** @description The name of another agent in this account scope, called as a sub-agent. */
+      agent?: string;
+      description?: string;
+      /** @description Defaults to true. */
+      enabled?: boolean;
+      /** @description The name of a flow in this account scope. */
+      flow?: string;
+      /** @description JSON Schema for the capability's input. Omit to derive it from the flow's inputs or the tool's own schema. */
+      parametersSchema?: {
+        [key: string]: unknown;
+      };
+      /** @description The name of a saved tool in this account scope. */
+      tool?: string;
+      /** @description The name the agent calls this capability by. */
+      toolName: string;
+    };
+    AgentEnsureCapabilityChange: {
+      /**
+       * @description What this converge did (on a dry run, would do) to the capability.
+       * @enum {string}
+       */
+      action: "add" | "update" | "remove" | "unchanged";
+      enabled: boolean;
+      /** @enum {string|null} */
+      kind: "flow" | "agent" | "tool" | null;
+      /** @description The flow, agent or tool name the capability calls. */
+      source: string | null;
+      toolName: string;
+    };
     AgentEnsureConflict: {
       /** @enum {string} */
       code: "external_modification" | "remote_changed";
@@ -50704,6 +51410,10 @@ interface components {
     AgentEnsureDeployment: {
       /** @description The release alias this converge aimed. */
       alias: string;
+      /** @description Per-alias secret binding names in force after this converge (on a dry run carrying deploy.bindings, the names it would leave in force). Never values. */
+      bindingNames?: string[];
+      /** @description Present on a dry run carrying deploy.bindings: whether the binding names differ from the ones the alias carries now. */
+      bindingsChanged?: boolean;
       /** @description Whether this converge moved the pointer (on a dry run, whether it would move it). */
       changed: boolean;
       /** @description The deployment receipt this converge appended. Absent when the pointer did not move. */
@@ -50738,6 +51448,8 @@ interface components {
     };
     AgentEnsureResponse: {
       agentId: string;
+      /** @description Present when the request carried capabilities: one row per declared capability, then removals. */
+      capabilityChanges?: components["schemas"]["AgentEnsureCapabilityChange"][];
       /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
       contentHash: string;
       deployment?: components["schemas"]["AgentEnsureDeployment"];
@@ -50745,6 +51457,8 @@ interface components {
       remoteHash?: string;
       /** @enum {string} */
       result: "unchanged" | "created" | "updated";
+      /** @description Present when the request carried skills: one row per declared binding, then unbinds. */
+      skillBindings?: components["schemas"]["AgentEnsureSkillBindingChange"][];
       /** @description The version snapshot backing this state (null if snapshotting failed). */
       versionId: string | null;
     } | {
@@ -50752,6 +51466,8 @@ interface components {
       result: "definitionRequired";
     } | {
       agentId?: string;
+      /** @description Present when the request carried capabilities: one row per declared capability, then removals. */
+      capabilityChanges?: components["schemas"]["AgentEnsureCapabilityChange"][];
       changedKeys: string[];
       /** @enum {string} */
       changes: "none" | "create" | "update";
@@ -50760,6 +51476,8 @@ interface components {
       remoteHash?: string;
       /** @enum {string} */
       result: "plan";
+      /** @description Present when the request carried skills: one row per declared binding, then unbinds. */
+      skillBindings?: components["schemas"]["AgentEnsureSkillBindingChange"][];
     };
     AgentEnsureServerError: {
       /** @description The release alias whose activation failed. No pointer was moved. */
@@ -50768,8 +51486,31 @@ interface components {
       code?: "alias_activation_failed";
       error: string;
     };
+    AgentEnsureSkillBinding: {
+      /** @description Defaults to true. */
+      enabled?: boolean;
+      /** @description The skill slug. */
+      name: string;
+      /** @description Pin this skill versionNumber. Omit to follow the skill's published version. */
+      version?: number;
+    };
+    AgentEnsureSkillBindingChange: {
+      /**
+       * @description What this converge did (on a dry run, would do) to the binding.
+       * @enum {string}
+       */
+      action: "bind" | "update" | "unbind" | "unchanged";
+      enabled: boolean;
+      /** @description The skill slug. */
+      name: string;
+      skillId: string;
+      /** @description The pinned versionNumber; null follows the published version. */
+      version: number | null;
+    };
     AgentPullResponse: {
       agentId: string;
+      /** @description The agent's capabilities in display order, in the shape ensure's capabilities accepts. parametersSchema appears only when it differs from the one ensure would derive. */
+      capabilities: components["schemas"]["AgentEnsureCapability"][];
       contentHash: string;
       definition: {
         config?: {
@@ -51070,6 +51811,8 @@ interface components {
         name: string;
       };
       lastModifiedSource: string | null;
+      /** @description The agent's skill bindings in load order, in the shape ensure's skills accepts. */
+      skills: components["schemas"]["AgentEnsureSkillBinding"][];
       updatedAt: string | null;
       versionId: string | null;
       /** @description Present only when a raw tool_… reference could not be emitted as a portable tool:<name> (the tool was deleted, or its name is shadowed by an older same-named tool). Those references are left as raw ids, which the ensure surface rejects; each warning explains how to fix it. */
@@ -51256,6 +51999,57 @@ interface components {
       /** @enum {string} */
       status: "pending" | "applied" | "settled" | "not_applied";
     };
+    CollectionEnsureConflict: {
+      /** @enum {string} */
+      code: "external_modification" | "remote_changed";
+      currentHash?: string | null;
+      error: string;
+      lastModifiedSource?: string;
+      modifiedAt?: string | null;
+    };
+    CollectionEnsureHashMismatch: {
+      /** @enum {string} */
+      code: "content_hash_mismatch";
+      /** @description The server-computed canonical hash of the submitted definition. */
+      contentHash: string;
+      error: string;
+    };
+    CollectionEnsureResponse: {
+      collectionId: string;
+      /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
+      contentHash: string;
+      /** @description Present when this ensure moved validationMode to enforce: a bounded dry-run of existing records against the schema, as PATCH reports. */
+      enforceCheck?: {
+        checked: number;
+        failed: number;
+        truncated: boolean;
+      };
+      /** @enum {string} */
+      result: "unchanged" | "created" | "updated";
+      schemaChange?: {
+        breakingChanges: string[];
+        /** @enum {string} */
+        kind: "additive" | "breaking";
+      };
+    } | {
+      /** @enum {string} */
+      result: "definitionRequired";
+    } | {
+      changedKeys: string[];
+      /** @enum {string} */
+      changes: "none" | "create" | "update";
+      collectionId?: string;
+      contentHash: string;
+      remoteHash?: string;
+      /** @enum {string} */
+      result: "plan";
+      /** @description How the schema would change. A breaking change is rejected when the resulting validationMode is enforce. */
+      schemaChange?: {
+        breakingChanges: string[];
+        /** @enum {string} */
+        kind: "additive" | "breaking";
+      };
+    };
     CollectionLookupFailedError: {
       /** @enum {string} */
       code: "COLLECTION_LOOKUP_FAILED";
@@ -51266,6 +52060,24 @@ interface components {
       recordId?: string;
       recordName?: string;
     };
+    CollectionPullResponse: {
+      collectionId: string;
+      contentHash: string;
+      definition: {
+        description: string | null;
+        displayName: string;
+        icon: string | null;
+        /** @description Constrained JSON Schema dialect: root object with string/number/boolean/array/object properties, one nesting level, no $ref/oneOf/pattern */
+        schema: {
+          [key: string]: unknown;
+        } | null;
+        slug: string;
+        /** @enum {string} */
+        validationMode: "off" | "warn" | "enforce";
+      };
+      lastModifiedSource: string | null;
+      updatedAt: string | null;
+    };
     ContextBlocks: {
       blocks: {
         /** @description The block text, scrubbed of secrets. */
@@ -52196,6 +53008,14 @@ interface components {
         name: string;
       }[];
     };
+    EvalEnsureConflict: {
+      /** @enum {string} */
+      code: "external_modification" | "remote_changed";
+      currentHash?: string | null;
+      error: string;
+      lastModifiedSource?: string;
+      modifiedAt?: string | null;
+    };
     EvalEnsureResponse: {
       /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
       contentHash: string;
@@ -52205,6 +53025,15 @@ interface components {
     } | {
       /** @enum {string} */
       result: "definitionRequired";
+    } | {
+      changedKeys: string[];
+      /** @enum {string} */
+      changes: "none" | "create" | "update";
+      contentHash: string;
+      remoteHash?: string;
+      /** @enum {string} */
+      result: "plan";
+      suiteId?: string;
     };
     /** @description Canonical eval override field. Replaces `stepOverrides` (and its `"*"` key), `claudeManagedOverride` and `advisorOverride`; setting both spellings of one channel is a 400. */
     EvalOverrides: {
@@ -53230,6 +54059,8 @@ interface components {
       changes: "none" | "create" | "update";
       contentHash: string;
       flowId?: string;
+      /** @description Present when the dry run carried release: "publish": whether the converge would re-aim the published version. */
+      publishPending?: boolean;
       remoteHash?: string;
       /** @enum {string} */
       result: "plan";
@@ -53505,11 +54336,16 @@ interface components {
       /** @description True when one or more entities failed to converge (re-run to self-heal). */
       hasFailures: boolean;
       productId?: string;
+      /** @description dryRun only: the live graph's pull-fpo hash, absent when the product does not exist or the caller cannot read every section. Pass it back as expectedRemoteHash to guard the apply. */
+      remoteHash?: string;
       /**
-       * @description `unchanged` when every entity was unchanged, `converged` when at least one was created/updated, `plan` for dryRun.
+       * @description `unchanged` when every entity was unchanged (a matching hash-only probe reports no entities), `converged` when at least one was created/updated, `plan` for dryRun.
        * @enum {string}
        */
       result: "unchanged" | "converged" | "plan";
+    } | {
+      /** @enum {string} */
+      result: "definitionRequired";
     };
     ProductFpoPullResponse: {
       /** @description Server-computed canonical whole-FPO content hash. */
@@ -53560,6 +54396,7 @@ interface components {
           productGoal?: string;
           /** @enum {string} */
           productStage?: "idea" | "prototype" | "beta" | "production" | "scaling";
+          stack?: components["schemas"]["ProductStack"];
           targetAudience?: string;
           techStack?: {
             backend?: string[];
@@ -53615,11 +54452,52 @@ interface components {
       currentVersionId: string | null;
       description: string | null;
       id: string;
+      /** @description The surface that last wrote the set; `sdk` or `terraform` means it is managed by code through ensure. */
+      lastModifiedSource?: string | null;
       name: string;
       organizationId: string;
       slug: string;
       updatedAt: string;
     };
+    QuestionSetEnsureConflict: {
+      /** @description external_modification, remote_changed, or a question set code such as QUESTION_SET_SLUG_TAKEN. */
+      code: string;
+      currentHash?: string | null;
+      error: string;
+      lastModifiedSource?: string;
+      modifiedAt?: string | null;
+    };
+    QuestionSetEnsureHashMismatch: {
+      /** @enum {string} */
+      code: "content_hash_mismatch";
+      /** @description The server-computed canonical hash of the submitted definition. */
+      contentHash: string;
+      error: string;
+    };
+    QuestionSetEnsureResponse: {
+      /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
+      contentHash: string;
+      /** @description The version executions resolve when they name none; null until a publish. */
+      publishedVersionNumber: number | null;
+      questionSetId: string;
+      /** @enum {string} */
+      result: "unchanged" | "created" | "updated";
+      /** @description The latest version, which the converged definition matches. */
+      versionId: string | null;
+      versionNumber: number | null;
+    } | {
+      /** @enum {string} */
+      result: "definitionRequired";
+    } | {
+      changedKeys: string[];
+      /** @enum {string} */
+      changes: "none" | "create" | "update";
+      contentHash: string;
+      questionSetId?: string;
+      remoteHash?: string;
+      /** @enum {string} */
+      result: "plan";
+    };
     QuestionSetError: components["schemas"]["Error"] & {
       /** @description Stable code, e.g. QUESTION_SET_INVALID or QUESTION_SET_UNRESOLVED. */
       code?: string;
@@ -53628,6 +54506,26 @@ interface components {
       currentVersionNumber: number | null;
       latestVersionNumber: number;
     };
+    QuestionSetPullResponse: {
+      contentHash: string;
+      definition: {
+        description?: string | null;
+        inputMapping?: {
+          [key: string]: string;
+        } | null;
+        model?: string | null;
+        name: string;
+        questions: {
+          [key: string]: unknown;
+        };
+        slug: string;
+      };
+      lastModifiedSource: string | null;
+      publishedVersionNumber: number | null;
+      questionSetId: string;
+      updatedAt: string | null;
+      versionNumber: number | null;
+    };
     QuestionSetVersion: {
       createdAt: string;
       createdByUserId: string | null;
@@ -53929,6 +54827,84 @@ interface components {
       kind: string;
       reason: string;
     };
+    ScheduleEnsureConflict: {
+      /** @enum {string} */
+      code: "external_modification" | "remote_changed";
+      currentHash?: string | null;
+      error: string;
+      lastModifiedSource?: string;
+      modifiedAt?: string | null;
+    };
+    ScheduleEnsureDefinition: {
+      /** @description Omit to leave the current paused/active state untouched; new schedules start enabled. */
+      enabled?: boolean;
+      executionOptions?: {
+        chunkSize?: number;
+        flowTimeoutMs?: number;
+        /** @enum {string} */
+        loggingPolicy?: "default" | "on" | "off";
+        maxRetries?: number;
+        modelOverride?: string;
+        progressFlushSize?: number;
+        recordConcurrency?: number;
+        skipCacheWarm?: boolean;
+        stepTimeoutMs?: number;
+        timeoutMs?: number;
+      };
+      inputs?: {
+        [key: string]: unknown;
+      };
+      messages?: {
+        [key: string]: unknown;
+      }[];
+      name: string;
+      recordFilter?: {
+        [key: string]: unknown;
+      };
+      recordIds?: string[];
+      recordType?: string;
+      target: components["schemas"]["ScheduleEnsureTarget"];
+      trigger: {
+        cron?: string;
+        /** Format: date-time */
+        runAt?: string;
+        timezone?: string;
+        /** @enum {string} */
+        type: "recurring" | "one_time";
+      };
+    };
+    ScheduleEnsureHashMismatch: {
+      /** @enum {string} */
+      code: "content_hash_mismatch";
+      /** @description The server-computed canonical hash of the submitted definition. */
+      contentHash: string;
+      error: string;
+    };
+    ScheduleEnsureResponse: {
+      /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
+      contentHash: string;
+      /** @enum {string} */
+      result: "unchanged" | "created" | "updated";
+      scheduleId: string;
+    } | {
+      /** @enum {string} */
+      result: "definitionRequired";
+    } | {
+      changedKeys: string[];
+      /** @enum {string} */
+      changes: "none" | "create" | "update";
+      contentHash: string;
+      remoteHash?: string;
+      /** @enum {string} */
+      result: "plan";
+      scheduleId?: string;
+    };
+    ScheduleEnsureTarget: {
+      agentId?: string;
+      agentName?: string;
+      flowId?: string;
+      flowName?: string;
+    };
     ScheduleEntitlementError: components["schemas"]["Error"] & {
       /** @description Stable error code (e.g. ACTIVE_SCHEDULE_LIMIT, SCHEDULE_FREQUENCY_LIMIT). */
       code?: string;
@@ -53937,6 +54913,13 @@ interface components {
       /** @description Dashboard-relative URL to the billing/upgrade page. */
       upgradeUrl?: string;
     };
+    SchedulePullResponse: {
+      contentHash: string;
+      definition: components["schemas"]["ScheduleEnsureDefinition"];
+      lastModifiedSource: string | null;
+      scheduleId: string;
+      updatedAt: string | null;
+    };
     ScheduleRunLink: {
       /** @description The agent_executions ROW id the scheduled run stored. Provenance only: a different id space from executionId, and never a /v1/runs key. */
       agentExecutionRowId: string | null;
@@ -54058,13 +55041,15 @@ interface components {
         };
         /** @enum {string} */
         environment?: "production" | "development";
+        /** @description Inbound channel config. Omit to keep the stored value; null clears it. A credential value of "<redacted>" (as returned by pull) keeps the stored credential. */
         inbound?: {
           [key: string]: unknown;
-        };
+        } | null;
         name: string;
+        /** @description Outbound channel config. Omit to keep the stored value; null clears it. A credential value of "<redacted>" (as returned by pull) keeps the stored credential. */
         outbound?: {
           [key: string]: unknown;
-        };
+        } | null;
         /** @enum {string} */
         status?: "draft" | "active" | "paused";
         /** @enum {string} */
@@ -57003,14 +57988,14 @@ export interface ScheduleMessageSet {
   messages: ScheduleMessage[];
 }
 export type ScheduleMessages = ScheduleMessage[] | ScheduleMessageSet[];
-export interface ScheduleTarget {
+interface ScheduleTarget$1 {
   flowId?: string;
   agentId?: string;
   recordIds?: string[];
   recordType?: string;
   recordFilter?: JsonValue | null;
 }
-export interface ScheduleTrigger {
+interface ScheduleTrigger$1 {
   type: 'one_time' | 'recurring';
   /** ISO 8601 datetime — required for `one_time` triggers. */
   runAt?: string;
@@ -57026,8 +58011,8 @@ export interface ScheduleTrigger {
  */
 export type Schedule = paths['/v1/schedules/{id}']['get']['responses'][200]['content']['application/json'];
 export interface CreateScheduleRequest {
-  target: ScheduleTarget;
-  trigger: ScheduleTrigger;
+  target: ScheduleTarget$1;
+  trigger: ScheduleTrigger$1;
   messages?: ScheduleMessages | null;
   executionOptions?: ScheduleExecutionOptions;
   /** Top-level input variables; keys must not start with `_`. */
@@ -57968,6 +58953,54 @@ interface EnsureEvalResult {
   /** The server-computed canonical hash (echo this — never your own). */
   contentHash: string;
 }
+/** The dry-run outcome of `client.evals.ensure(definition, { dryRun: true })`. */
+interface EnsureEvalPlan {
+  result: 'plan';
+  changes: 'none' | 'create' | 'update';
+  /** Coarse keys that differ: `target`, `cases`, `recordedToolMode`, `recordedToolUnmatchedPolicy`. */
+  changedKeys: string[];
+  contentHash: string;
+  /** The live suite's hash, computed over the cases ensure owns; bind an apply to it with `expectedRemoteHash`. */
+  remoteHash?: string;
+  suiteId?: string;
+}
+interface EnsureEvalOptions {
+  /** Plan without writing (the CI drift gate). Sends the full definition. */
+  dryRun?: boolean;
+  /**
+   * What to do when the suite's last write came from the dashboard/API rather
+   * than ensure. Default 'error' (HTTP 409 → EvalEnsureConflictError).
+   */
+  onConflict?: 'error' | 'overwrite';
+  /** TOCTOU guard binding a dry run to its apply (409 remote_changed otherwise). */
+  expectedRemoteHash?: string;
+  /** Implies dryRun; throws EvalDriftError unless the plan is 'none'. */
+  expectNoChanges?: boolean;
+}
+/** Options for a converging (non-plan) ensure. */
+type EnsureEvalApplyOptions = Omit<EnsureEvalOptions, 'dryRun' | 'expectNoChanges'> & {
+  dryRun?: false;
+  expectNoChanges?: false;
+};
+/** A 409 from the eval ensure protocol (external_modification or remote_changed). */
+export declare class EvalEnsureConflictError extends Error {
+  readonly code: 'external_modification' | 'remote_changed';
+  readonly lastModifiedSource?: string;
+  readonly modifiedAt?: string | null;
+  readonly currentHash?: string | null;
+  constructor(body: {
+    error?: string;
+    code: 'external_modification' | 'remote_changed';
+    lastModifiedSource?: string;
+    modifiedAt?: string | null;
+    currentHash?: string | null;
+  });
+}
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+export declare class EvalDriftError extends Error {
+  readonly plan: EnsureEvalPlan;
+  constructor(plan: EnsureEvalPlan);
+}
 /** The canonical definition + provenance returned by `client.evals.pull(name)`. */
 interface EvalPullResult {
   suiteId: string;
@@ -58172,15 +59205,17 @@ type RunEvalInput = {
 };
 /**
  * Idempotently converge an eval suite definition onto the platform. Hash-first:
- * probes with a content hash, and only ships the full definition when the
- * server reports a miss (`definitionRequired`). Upserts the suite + replaces
- * its cases; never executes the eval (use the `runtype eval` CLI / `/eval`
- * submit surface to run it).
- *
- * `virtual: true` definitions are ephemeral and have nothing durable to
- * converge — ensure rejects them. Run a virtual eval directly instead.
+ * probes with a content hash, and only ships the full definition on a miss.
+ * Replaces only the cases ensure owns: cases saved from runs or added in the
+ * dashboard survive. Never executes the eval. Virtual evals cannot be ensured.
  */
-export declare function ensureEval(client: RuntypeClient$1, definition: EvalDefinition): Promise<EnsureEvalResult>;
+export declare function ensureEval(client: RuntypeClient$1, definition: EvalDefinition, options: EnsureEvalOptions & ({
+  dryRun: true;
+} | {
+  expectNoChanges: true;
+})): Promise<EnsureEvalPlan>;
+export declare function ensureEval(client: RuntypeClient$1, definition: EvalDefinition, options?: EnsureEvalApplyOptions): Promise<EnsureEvalResult>;
+export declare function ensureEval(client: RuntypeClient$1, definition: EvalDefinition, options?: EnsureEvalOptions): Promise<EnsureEvalResult | EnsureEvalPlan>;
 /**
  * Pull the canonical definition + provenance for an eval suite by name — the
  * absorb-drift direction of the ensure protocol. The contentHash reflects the
@@ -58280,6 +59315,7 @@ interface EnsureFlowOptions {
   /**
    * What to do when the flow's last write came from the dashboard/API
    * rather than ensure. Default 'error' (HTTP 409 → FlowEnsureConflictError).
+   * Also applies to the flow's inline evals (409 → EvalEnsureConflictError).
    */
   onConflict?: 'error' | 'overwrite';
   /** 'publish' also re-aims the published-version pointer. Default 'none'. */
@@ -58295,7 +59331,10 @@ interface EnsureFlowOptions {
    * server-generated notes.
    */
   version?: components['schemas']['EnsureVersionMetadata'];
-  /** Implies dryRun; throws FlowDriftError unless the plan is 'none'. */
+  /**
+   * Implies dryRun; throws FlowDriftError unless the plan is 'none' and, with
+   * `release: 'publish'`, no publish is pending.
+   */
   expectNoChanges?: boolean;
 }
 interface EnsureFlowConverged {
@@ -58320,6 +59359,8 @@ interface EnsureFlowPlan {
   contentHash: string;
   remoteHash?: string;
   flowId?: string;
+  /** Present when the dry run carried `release: 'publish'`: whether it would re-aim the published version. */
+  publishPending?: boolean;
 }
 type EnsureFlowResult = EnsureFlowConverged | EnsureFlowPlan;
 interface FlowPullResult {
@@ -58944,7 +59985,7 @@ interface EvalSuiteDetail extends EvalSuiteSummary {
   } | null;
 }
 /** Case provenance (mirror of `EvalCaseOrigin` in `@runtypelabs/shared`). */
-type EvalCaseOrigin = 'manual' | 'saved_from_run' | 'generated' | 'imported' | 'fpo';
+type EvalCaseOrigin = 'manual' | 'saved_from_run' | 'generated' | 'imported' | 'fpo' | 'ensure';
 /** One case to create. */
 interface EvalSuiteCaseInput {
   name: string;
@@ -59475,7 +60516,9 @@ export declare class EvalsNamespace {
    * Idempotently converge a `defineEval` suite definition onto the platform —
    * the deploy-time, non-executing converge for code-colocated evals. Hash-first:
    * the steady state is one tiny probe request. Upserts the eval suite + replaces
-   * its cases; never runs the eval.
+   * the cases ensure owns (captured and dashboard cases survive); never runs the
+   * eval. `dryRun` / `expectNoChanges` plan without writing; a dashboard edit
+   * answers 409 unless `onConflict: 'overwrite'`.
    *
    * @example
    * ```typescript
@@ -59487,7 +60530,13 @@ export declare class EvalsNamespace {
    * const result = await Runtype.evals.ensure(suite)
    * ```
    */
-  ensure(definition: EvalDefinition): Promise<EnsureEvalResult>;
+  ensure(definition: EvalDefinition, options: EnsureEvalOptions & ({
+    dryRun: true;
+  } | {
+    expectNoChanges: true;
+  })): Promise<EnsureEvalPlan>;
+  ensure(definition: EvalDefinition, options?: EnsureEvalApplyOptions): Promise<EnsureEvalResult>;
+  ensure(definition: EvalDefinition, options?: EnsureEvalOptions): Promise<EnsureEvalResult | EnsureEvalPlan>;
   /**
    * Pull the canonical definition + provenance for an eval suite by name — the
    * absorb-drift direction of the ensure protocol.
@@ -59810,6 +60859,12 @@ interface EnsureSkillOptions {
    * remote still hashes to this value (409 remote_changed otherwise).
    */
   expectedRemoteHash?: string;
+  /**
+   * Provenance stamped on the version row this converge appends (a git SHA, a
+   * release tag). Omit to keep the default 'sdk-ensure' label and the
+   * server-generated notes.
+   */
+  version?: components['schemas']['EnsureVersionMetadata'];
   /** Implies dryRun; throws SkillDriftError unless the plan is 'none'. */
   expectNoChanges?: boolean;
 }
@@ -59953,7 +61008,7 @@ interface SkillVersion {
   createdAt: string;
 }
 /** An agent ↔ skill binding row. */
-interface AgentSkillBinding {
+interface AgentSkillBinding$1 {
   id: string;
   agentId: string;
   skillId: string;
@@ -59968,7 +61023,7 @@ interface AgentSkillBinding {
  * {@link SkillsNamespace.listBindingsForSkill}, the by-skill twin of
  * {@link SkillsNamespace.listBindings}.
  */
-interface SkillBindingWithAgent extends AgentSkillBinding {
+interface SkillBindingWithAgent extends AgentSkillBinding$1 {
   agent: {
     id: string;
     name: string;
@@ -60236,7 +61291,7 @@ export declare class SkillsNamespace {
    * Bind a skill to an agent. Both the agent and the skill must be owned by the
    * caller.
    */
-  bind(input: BindSkillInput): Promise<AgentSkillBinding>;
+  bind(input: BindSkillInput): Promise<AgentSkillBinding$1>;
   /**
    * Remove a skill binding by its binding id.
    */
@@ -60249,7 +61304,7 @@ export declare class SkillsNamespace {
    * const bindings = await Runtype.skills.listBindings('agent_123')
    * ```
    */
-  listBindings(agentId: string): Promise<AgentSkillBinding[]>;
+  listBindings(agentId: string): Promise<AgentSkillBinding$1[]>;
   /**
    * List every agent a skill is bound to, each row joined with the agent's name
    * and type. The by-agent twin is {@link listBindings}.
@@ -60714,8 +61769,61 @@ interface EnsureAgentOptions {
    * server-generated notes.
    */
   version?: components['schemas']['EnsureVersionMetadata'];
-  /** Implies dryRun; throws AgentDriftError unless the plan is 'none'. */
+  /**
+   * Implies dryRun; throws AgentDriftError unless the plan is 'none', no skill
+   * binding would change and, with `release` or `deploy`, the alias would not move.
+   */
   expectNoChanges?: boolean;
+  /**
+   * The complete set of skills bound to the agent, in load order. `version`
+   * pins a skill versionNumber; omit it to follow the published version.
+   * Bound skills absent here are unbound; omit the option to leave bindings alone.
+   */
+  skills?: AgentSkillBinding[];
+  /**
+   * The complete set of capabilities (flow, sub-agent and saved-tool
+   * attachments) in display order. Capabilities absent here are removed; omit
+   * the option to leave them alone. When present they are part of the content hash.
+   */
+  capabilities?: AgentCapabilityDeclaration[];
+}
+/** @example `{ toolName: 'lookup_order', flow: 'Order Lookup' }` attaches the flow named "Order Lookup". */
+interface AgentCapabilityDeclaration {
+  /** The name the agent calls this capability by. */
+  toolName: string;
+  /** Exactly one of `flow`, `agent` or `tool`: the source's name in this account. */
+  flow?: string;
+  agent?: string;
+  tool?: string;
+  description?: string;
+  /** Omit to derive it from the flow's inputs or the tool's own schema. */
+  parametersSchema?: Record<string, unknown>;
+  enabled?: boolean;
+}
+/** What one ensure did (or, on a dry run, would do) to a declared or removed capability. */
+interface AgentCapabilityChange {
+  toolName: string;
+  action: 'add' | 'update' | 'remove' | 'unchanged';
+  kind: 'flow' | 'agent' | 'tool' | null;
+  /** The flow, agent or tool name the capability calls. */
+  source: string | null;
+  enabled: boolean;
+}
+/** @example `{ name: 'refund-policy', version: 3 }` pins version 3; `{ name: 'tone-guide' }` follows published. */
+interface AgentSkillBinding {
+  /** The skill slug. */
+  name: string;
+  version?: number;
+  enabled?: boolean;
+}
+/** What one ensure did (or, on a dry run, would do) to a declared or removed binding. */
+interface AgentSkillBindingChange {
+  name: string;
+  skillId: string;
+  action: 'bind' | 'update' | 'unbind' | 'unchanged';
+  /** The pinned versionNumber; null follows the published version. */
+  version: number | null;
+  enabled: boolean;
 }
 interface EnsureAgentConverged {
   result: 'unchanged' | 'created' | 'updated';
@@ -60727,6 +61835,10 @@ interface EnsureAgentConverged {
   remoteHash?: string;
   /** The pointer this converge aimed, present only when it carried release or deploy. */
   deployment?: AgentEnsureDeployment;
+  /** Present when the request carried `skills`. */
+  skillBindings?: AgentSkillBindingChange[];
+  /** Present when the request carried `capabilities`. */
+  capabilityChanges?: AgentCapabilityChange[];
 }
 interface EnsureAgentPlan {
   result: 'plan';
@@ -60737,6 +61849,10 @@ interface EnsureAgentPlan {
   agentId?: string;
   /** The pointer this dry run would aim, and whether it would move. */
   deployment?: AgentEnsureDeployment;
+  /** Present when the request carried `skills`. */
+  skillBindings?: AgentSkillBindingChange[];
+  /** Present when the request carried `capabilities`. */
+  capabilityChanges?: AgentCapabilityChange[];
 }
 type EnsureAgentResult = EnsureAgentConverged | EnsureAgentPlan;
 interface AgentPullResult {
@@ -60753,6 +61869,10 @@ interface AgentPullResult {
    * `defineAgent`/`ensure` reject — so each warning explains how to fix it.
    */
   warnings?: string[];
+  /** The agent's skill bindings, ready to pass back as the `skills` ensure option. */
+  skills: AgentSkillBinding[];
+  /** The agent's capabilities, ready to pass back as the `capabilities` ensure option. */
+  capabilities: AgentCapabilityDeclaration[];
 }
 /** A 409 from the ensure protocol (external_modification or remote_changed). */
 export declare class AgentEnsureConflictError extends Error {
@@ -61135,6 +62255,115 @@ export declare class ToolsNamespace {
   pull(name: string): Promise<ToolPullResult>;
 }
 //#endregion
+//#region src/question-sets-ensure.d.ts
+/** A question set declared in code. `slug` is its identity within the organization. */
+interface QuestionSetDefinition {
+  slug: string;
+  name: string;
+  description?: string | null;
+  /** Judgment questions keyed by question id, e.g. `{ urgent: { type: 'boolean', instructions: '...' } }`. */
+  questions: Record<string, unknown>;
+  inputMapping?: Record<string, string> | null;
+  model?: string | null;
+}
+/** Canonical form of a question set definition, without its slug. */
+export declare function normalizeQuestionSetDefinition(definition: QuestionSetDefinition): Record<string, unknown>;
+/** SHA-256 (hex) over the canonical question set definition. */
+export declare function computeQuestionSetContentHash(definition: QuestionSetDefinition): Promise<string>;
+/**
+ * Pure local constructor for a question set definition. Checks the structure
+ * and rejects unknown fields; the server validates the questions at ensure time.
+ *
+ * @example
+ * ```typescript
+ * const triage = defineQuestionSet({
+ *   slug: 'ticket-triage',
+ *   name: 'Ticket triage',
+ *   questions: { urgent: { type: 'boolean', instructions: 'Is the ticket urgent?' } },
+ * })
+ * ```
+ */
+export declare function defineQuestionSet(input: QuestionSetDefinition): QuestionSetDefinition;
+interface EnsureQuestionSetOptions {
+  /** Plan without writing (the CI drift gate). Sends the full definition. */
+  dryRun?: boolean;
+  /** What to do when the last write came from the dashboard or API. Default 'error' (409). */
+  onConflict?: 'error' | 'overwrite';
+  /** 'publish' makes the latest version the one executions resolve. Default 'none'. */
+  release?: 'none' | 'publish';
+  /** Apply only if the remote still hashes to this value (409 remote_changed otherwise). */
+  expectedRemoteHash?: string;
+  /** Implies dryRun; throws QuestionSetDriftError unless the plan is 'none'. */
+  expectNoChanges?: boolean;
+}
+interface EnsureQuestionSetConverged {
+  result: 'unchanged' | 'created' | 'updated';
+  questionSetId: string;
+  versionId: string | null;
+  versionNumber: number | null;
+  publishedVersionNumber: number | null;
+  /** The server-computed canonical hash; echo this one, never your own. */
+  contentHash: string;
+}
+interface EnsureQuestionSetPlan {
+  result: 'plan';
+  changes: 'none' | 'create' | 'update';
+  changedKeys: string[];
+  contentHash: string;
+  remoteHash?: string;
+  questionSetId?: string;
+}
+type EnsureQuestionSetResult = EnsureQuestionSetConverged | EnsureQuestionSetPlan;
+interface QuestionSetPullResult {
+  questionSetId: string;
+  definition: QuestionSetDefinition;
+  contentHash: string;
+  lastModifiedSource: string | null;
+  updatedAt: string | null;
+  versionNumber: number | null;
+  publishedVersionNumber: number | null;
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+export declare class QuestionSetEnsureConflictError extends Error {
+  readonly code: 'external_modification' | 'remote_changed';
+  readonly lastModifiedSource?: string;
+  readonly modifiedAt?: string | null;
+  readonly currentHash?: string | null;
+  constructor(body: {
+    error?: string;
+    code: 'external_modification' | 'remote_changed';
+    lastModifiedSource?: string;
+    modifiedAt?: string | null;
+    currentHash?: string | null;
+  });
+}
+/** Thrown by `ensure(def, { expectNoChanges: true })` when the remote differs. */
+export declare class QuestionSetDriftError extends Error {
+  readonly plan: EnsureQuestionSetPlan;
+  constructor(slug: string, plan: EnsureQuestionSetPlan);
+}
+//#endregion
+//#region src/question-sets-namespace.d.ts
+/** Question set config-as-code: `ensure` and `pull`. */
+export declare class QuestionSetsNamespace {
+  private getClient;
+  constructor(getClient: () => RuntypeClient$1);
+  /**
+   * Converge a `defineQuestionSet` definition. The steady state is one hash
+   * probe. Pass `release: 'publish'` so flows and agents can resolve the
+   * latest version.
+   *
+   * @example
+   * ```typescript
+   * await Runtype.questionSets.ensure(triage, { release: 'publish' })
+   * await Runtype.questionSets.ensure(triage, { expectNoChanges: true })
+   * ```
+   */
+  ensure(definition: QuestionSetDefinition, options?: EnsureQuestionSetOptions): Promise<EnsureQuestionSetResult>;
+  /** Pull the live definition and provenance for a slug, to absorb a dashboard edit. */
+  pull(slug: string): Promise<QuestionSetPullResult>;
+}
+//#endregion
 //#region src/products-ensure.d.ts
 /** Canonical normalized form of a product definition (name + canvas excluded). */
 export declare function normalizeProductDefinition(definition: ProductContentInput): {
@@ -61267,6 +62496,28 @@ interface EnsureFpoOptions {
    * plan rows.
    */
   prune?: boolean;
+  /** Implies dryRun; throws FpoDriftError when any entity would be created, updated, pruned or fails. */
+  expectNoChanges?: boolean;
+  /**
+   * TOCTOU guard: pass the dry run's `remoteHash`; the write proceeds only while
+   * the live graph still hashes to it (ProductEnsureConflictError `remote_changed`
+   * otherwise). The hash covers what `pullFpo` reconstructs, so seed records,
+   * schedules and secrets are outside it.
+   */
+  expectedRemoteHash?: string;
+  /**
+   * With `release: 'none'`, send a hash-only probe first and skip the full FPO
+   * when the live graph reconstructs to the same hash. A publishing converge
+   * (the default release) always ships the full FPO, since only it can publish
+   * drafts that are not yet live.
+   */
+  hashProbe?: boolean;
+  /**
+   * Whether converged capability agents and flows go live. The server defaults
+   * to `'publish'` (version, publish and move the agent's `live` alias, as
+   * product creation does); `'none'` saves changes as drafts.
+   */
+  release?: 'none' | 'publish';
 }
 /** One nested entity's converge result. */
 interface FpoEntityOutcome {
@@ -61281,9 +62532,17 @@ interface EnsureFpoResult {
   result: 'unchanged' | 'converged' | 'plan';
   productId?: string;
   contentHash: string;
+  /** dryRun only: the live graph's hash, to pass back as `expectedRemoteHash`. */
+  remoteHash?: string;
   entities: FpoEntityOutcome[];
   hasFailures: boolean;
 }
+/** Thrown by `ensureFpo(fpo, { expectNoChanges: true })` when the plan is not clean. */
+export declare class FpoDriftError extends Error {
+  readonly plan: EnsureFpoResult;
+  constructor(plan: EnsureFpoResult);
+}
+export declare function fpoPlanHasDrift(plan: EnsureFpoResult): boolean;
 interface PullFpoResult {
   productId: string;
   /**
@@ -61297,10 +62556,10 @@ interface PullFpoResult {
   warnings?: string[];
 }
 /**
- * Converge an entire FPO onto the platform. Ships the full FPO (no hash-only
- * probe in this release); the server fans out to the per-entity ensure services
- * and returns the whole-FPO hash + per-entity report. Non-atomic: inspect
- * `result.hasFailures` / `entities[].result` and re-run to self-heal.
+ * Converge an entire FPO onto the platform. Ships the full FPO unless a
+ * drafts-only `hashProbe` finds the live graph already matches; the server fans out to the
+ * per-entity ensure services and returns the whole-FPO hash + per-entity report.
+ * Non-atomic: inspect `result.hasFailures` / `entities[].result` and re-run to self-heal.
  */
 export declare function ensureFpo(client: RuntypeClient$1, fpo: FpoInput, options?: EnsureFpoOptions): Promise<EnsureFpoResult>;
 /**
@@ -61429,8 +62688,10 @@ interface DefineSurfaceInput {
   name: string;
   type: SurfaceDefinitionType;
   behavior?: Record<string, unknown>;
-  inbound?: Record<string, unknown>;
-  outbound?: Record<string, unknown>;
+  /** Omit to keep the stored value; null clears it; a `'<redacted>'` credential keeps the stored secret. */
+  inbound?: Record<string, unknown> | null;
+  /** Omit to keep the stored value; null clears it; a `'<redacted>'` credential keeps the stored secret. */
+  outbound?: Record<string, unknown> | null;
   status?: SurfaceDefinitionStatus;
 }
 /** The canonical (wire) definition produced by `defineSurface`. */
@@ -61438,8 +62699,10 @@ interface SurfaceDefinition {
   name: string;
   type: SurfaceDefinitionType;
   behavior?: Record<string, unknown>;
-  inbound?: Record<string, unknown>;
-  outbound?: Record<string, unknown>;
+  /** Omit to keep the stored value; null clears it; a `'<redacted>'` credential keeps the stored secret. */
+  inbound?: Record<string, unknown> | null;
+  /** Omit to keep the stored value; null clears it; a `'<redacted>'` credential keeps the stored secret. */
+  outbound?: Record<string, unknown> | null;
   status?: SurfaceDefinitionStatus;
 }
 /**
@@ -62267,6 +63530,23 @@ export declare class Runtype {
    * ```
    */
   static get tools(): ToolsNamespace;
+  /**
+   * Question sets namespace - Question set config-as-code (define / ensure / pull)
+   *
+   * @example
+   * ```typescript
+   * import { defineQuestionSet, Runtype } from '@runtypelabs/sdk'
+   *
+   * const triage = defineQuestionSet({
+   *   slug: 'ticket-triage',
+   *   name: 'Ticket triage',
+   *   questions: { urgent: { type: 'boolean', instructions: 'Is the ticket urgent?' } },
+   * })
+   *
+   * await Runtype.questionSets.ensure(triage, { release: 'publish' })
+   * ```
+   */
+  static get questionSets(): QuestionSetsNamespace;
   /**
    * Products namespace - Product config-as-code (define / ensure / pull)
    *
@@ -62464,6 +63744,238 @@ interface PromoteAgentResult {
  */
 export declare function promoteAgent(input: PromoteAgentInput): Promise<PromoteAgentResult>;
 //#endregion
+//#region src/schedules-ensure.d.ts
+/** Exactly one key: a flow or agent by id, or by name (portable across environments). */
+export type ScheduleTarget = {
+  flowId: string;
+} | {
+  agentId: string;
+} | {
+  flowName: string;
+} | {
+  agentName: string;
+};
+export type ScheduleTrigger = {
+  type: 'recurring';
+  cron: string;
+  timezone: string;
+  runAt?: string;
+} | {
+  type: 'one_time';
+  runAt: string;
+  cron?: string;
+  timezone?: string;
+};
+type ScheduleDefinitionMessage = {
+  role: 'system' | 'user' | 'assistant';
+  content: unknown;
+} | {
+  name?: string;
+  messages: Array<{
+    role: 'system' | 'user' | 'assistant';
+    content: unknown;
+  }>;
+};
+/** The canonical (wire) definition produced by `defineSchedule`. */
+interface ScheduleDefinition {
+  name: string;
+  target: ScheduleTarget;
+  trigger: ScheduleTrigger;
+  recordIds?: string[];
+  recordType?: string;
+  recordFilter?: Record<string, unknown>;
+  messages?: ScheduleDefinitionMessage[];
+  inputs?: Record<string, unknown>;
+  executionOptions?: Record<string, unknown>;
+  /** Omit to leave the schedule's paused/active state alone; new schedules start enabled. */
+  enabled?: boolean;
+}
+type DefineScheduleInput = ScheduleDefinition;
+interface ScheduleContentInput {
+  triggerType: string;
+  cron?: string | null;
+  timezone?: string | null;
+  runAt?: string | Date | null;
+  recordIds?: string[] | null;
+  recordType?: string | null;
+  recordFilter?: Record<string, unknown> | null;
+  messages?: unknown[] | null;
+  inputs?: Record<string, unknown> | null;
+  executionOptions?: Record<string, unknown> | null;
+  enabled?: boolean | null;
+}
+/** Canonical normalized schedule content (name and target excluded — identity). */
+export declare function normalizeScheduleContent(definition: ScheduleContentInput): Record<string, unknown>;
+/** SHA-256 (hex) over canonical schedule content, in the flat content shape. */
+export declare function computeScheduleContentHash(definition: ScheduleContentInput): Promise<string>;
+/** The content hash of a `defineSchedule` definition. */
+export declare function computeScheduleDefinitionHash(definition: ScheduleDefinition): Promise<string>;
+/**
+ * Pure-local declarative constructor for a standalone schedule. No I/O.
+ * Validates structure; cron, timezone, record filter and plan limits are
+ * checked server-side at ensure time.
+ *
+ * @example
+ * ```typescript
+ * const nightly = defineSchedule({
+ *   name: 'Nightly digest',
+ *   target: { flowName: 'Digest' },
+ *   trigger: { type: 'recurring', cron: '0 2 * * *', timezone: 'UTC' },
+ * })
+ * ```
+ */
+export declare function defineSchedule(input: DefineScheduleInput): ScheduleDefinition;
+interface EnsureScheduleOptions {
+  /** Plan without writing (the CI drift gate). Sends the full definition. */
+  dryRun?: boolean;
+  /** What to do when the last write was not ensure. Default 'error' (409). */
+  onConflict?: 'error' | 'overwrite';
+  /** TOCTOU guard from a dry run; the full definition is always sent with it. */
+  expectedRemoteHash?: string;
+  /** Implies dryRun; throws ScheduleDriftError unless the plan is 'none'. */
+  expectNoChanges?: boolean;
+}
+interface EnsureScheduleConverged {
+  result: 'unchanged' | 'created' | 'updated';
+  scheduleId: string;
+  /** The server-computed canonical hash (echo this — never your own). */
+  contentHash: string;
+}
+interface EnsureSchedulePlan {
+  result: 'plan';
+  changes: 'none' | 'create' | 'update';
+  changedKeys: string[];
+  contentHash: string;
+  remoteHash?: string;
+  scheduleId?: string;
+}
+type EnsureScheduleResult = EnsureScheduleConverged | EnsureSchedulePlan;
+interface SchedulePullResult {
+  scheduleId: string;
+  definition: ScheduleDefinition;
+  contentHash: string;
+  lastModifiedSource: string | null;
+  updatedAt: string | null;
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+export declare class ScheduleEnsureConflictError extends Error {
+  readonly code: 'external_modification' | 'remote_changed';
+  readonly lastModifiedSource?: string;
+  readonly modifiedAt?: string | null;
+  readonly currentHash?: string | null;
+  constructor(body: {
+    error?: string;
+    code: 'external_modification' | 'remote_changed';
+    lastModifiedSource?: string;
+    modifiedAt?: string | null;
+    currentHash?: string | null;
+  });
+}
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+export declare class ScheduleDriftError extends Error {
+  readonly plan: EnsureSchedulePlan;
+  constructor(plan: EnsureSchedulePlan);
+}
+/** The request surface ensure needs; both SDK clients satisfy it. */
+interface ScheduleEnsureTransport {
+  get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
+  post<T>(path: string, data?: unknown): Promise<T>;
+}
+/**
+ * Idempotently converge a standalone schedule. Hash-first: probes with a
+ * content hash and ships the full definition only on a miss. Never deletes.
+ */
+export declare function ensureSchedule(client: ScheduleEnsureTransport, definition: ScheduleDefinition, options?: EnsureScheduleOptions): Promise<EnsureScheduleResult>;
+/** Pull the canonical definition + provenance for a schedule by name and target. */
+export declare function pullSchedule(client: ScheduleEnsureTransport, name: string, target: ScheduleTarget): Promise<SchedulePullResult>;
+//#endregion
+//#region src/collections-ensure.d.ts
+type RecordCollectionValidationMode = 'off' | 'warn' | 'enforce';
+/** A repo-declared record collection. `slug` is identity; omitted fields converge to create defaults. */
+interface RecordCollectionDefinition {
+  slug: string;
+  displayName: string;
+  description?: string | null;
+  icon?: string | null;
+  schema?: Record<string, unknown> | null;
+  validationMode?: RecordCollectionValidationMode;
+}
+/** Canonical normalized form of a collection definition (slug excluded — identity). */
+export declare function normalizeRecordCollectionDefinition(definition: RecordCollectionDefinition): {
+  displayName: string;
+  description?: string;
+  icon?: string;
+  schema?: Record<string, unknown>;
+  validationMode: string;
+};
+/** SHA-256 (hex) over the canonical normalized collection definition. */
+export declare function computeRecordCollectionContentHash(definition: RecordCollectionDefinition): Promise<string>;
+interface EnsureCollectionOptions {
+  /** Plan without writing (the CI drift gate). Sends the full definition. */
+  dryRun?: boolean;
+  /** What to do when the last write came from the dashboard/API. Default 'error' (409). */
+  onConflict?: 'error' | 'overwrite';
+  /** TOCTOU guard binding a dry run to its apply (409 remote_changed otherwise). */
+  expectedRemoteHash?: string;
+  /** Implies dryRun; throws CollectionDriftError unless the plan is 'none'. */
+  expectNoChanges?: boolean;
+}
+interface CollectionSchemaChange {
+  kind: 'additive' | 'breaking';
+  breakingChanges: string[];
+}
+interface EnsureCollectionConverged {
+  result: 'unchanged' | 'created' | 'updated';
+  collectionId: string;
+  /** The server-computed canonical hash (echo this — never your own). */
+  contentHash: string;
+  schemaChange?: CollectionSchemaChange;
+  /** Present when this ensure moved validationMode to `enforce`: existing records checked against the schema. */
+  enforceCheck?: {
+    checked: number;
+    failed: number;
+    truncated: boolean;
+  };
+}
+interface EnsureCollectionPlan {
+  result: 'plan';
+  changes: 'none' | 'create' | 'update';
+  changedKeys: string[];
+  contentHash: string;
+  remoteHash?: string;
+  collectionId?: string;
+  schemaChange?: CollectionSchemaChange;
+}
+type EnsureCollectionResult = EnsureCollectionConverged | EnsureCollectionPlan;
+interface CollectionPullResult {
+  collectionId: string;
+  definition: Required<Omit<RecordCollectionDefinition, 'validationMode'>> & {
+    validationMode: RecordCollectionValidationMode;
+  };
+  contentHash: string;
+  lastModifiedSource: string | null;
+  updatedAt: string | null;
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+export declare class CollectionEnsureConflictError extends Error {
+  readonly code: 'external_modification' | 'remote_changed';
+  readonly lastModifiedSource?: string;
+  readonly modifiedAt?: string | null;
+  readonly currentHash?: string | null;
+  constructor(body: {
+    error?: string;
+    code: 'external_modification' | 'remote_changed';
+    lastModifiedSource?: string;
+    modifiedAt?: string | null;
+    currentHash?: string | null;
+  });
+}
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+export declare class CollectionDriftError extends Error {
+  readonly plan: EnsureCollectionPlan;
+  constructor(slug: string, plan: EnsureCollectionPlan);
+}
+//#endregion
 //#region src/api-key-request-types.d.ts
 /**
  * Agent API key request types.
@@ -63201,6 +64713,24 @@ export declare class CollectionsEndpoint {
    * `RecordCollections` map so `client.records.from(slug)` types metadata.
    */
   typegen(): Promise<string>;
+  /**
+   * Idempotently converge a repo-declared collection (display fields, schema,
+   * validationMode) by slug. Hash-first; `dryRun` / `expectNoChanges` plan
+   * without writing. Never deletes a collection or touches records.
+   *
+   * @example
+   * ```typescript
+   * await client.collections.ensure({
+   *   slug: 'customers',
+   *   displayName: 'Customers',
+   *   schema: { type: 'object', properties: { status: { type: 'string' } } },
+   *   validationMode: 'warn',
+   * })
+   * ```
+   */
+  ensure(definition: RecordCollectionDefinition, options?: EnsureCollectionOptions): Promise<EnsureCollectionResult>;
+  /** Pull the canonical definition and provenance for a collection — the absorb-drift direction. */
+  pull(slug: string): Promise<CollectionPullResult>;
 }
 /**
  * Agent API key REQUESTS — a device-authorization-style grant.
@@ -65542,6 +67072,17 @@ export declare class SchedulesEndpoint {
    * Create a schedule. Provide exactly one of `target.flowId` or `target.agentId`.
    */
   create(data: CreateScheduleRequest): Promise<ScheduleMutationResponse>;
+  /**
+   * Idempotently converge a `defineSchedule` definition on a standalone flow or
+   * agent. Identity is name + target; the steady state is one hash probe. Never
+   * deletes, and an omitted `enabled` leaves a paused schedule paused.
+   */
+  ensure(definition: ScheduleDefinition, options?: EnsureScheduleOptions): Promise<EnsureScheduleResult>;
+  /**
+   * Pull the canonical definition + provenance for a schedule by name and
+   * target — the absorb-drift direction of `ensure`.
+   */
+  pull(name: string, target: ScheduleTarget): Promise<SchedulePullResult>;
   /**
    * Update a schedule (partial update supported).
    */
@@ -67443,5 +68984,5 @@ export declare function getLikelySupportingCandidatePaths(bestCandidatePath: str
 export declare function getDefaultPlanPath(taskName: string): string;
 export declare function sanitizeTaskSlug(taskName: string): string;
 //#endregion
-export type { AIGrader, ActivateAgentAliasInput, ActivateAgentPromotionInput, AgentAlias, AgentAliasActivation, AgentAliasArchiveFailure, AgentAliasArchived, AgentAliasList, AgentAliasTransport, AgentDefinition, AgentDefinitionConfig, AgentDeploymentList, AgentDeploymentPromotion, AgentDeploymentReceipt, AgentPromotionManifest, AgentPromotionTransport, AgentPromotionValidation, AgentPullResult, AgentStreamEvent, ApiKeyRequest, ApiKeyRequestDelivery, ApiKeyRequestEnvironment, ApiKeyRequestHandoff, ApiKeyRequestListParams, ApiKeyRequestRequester, ApiKeyRequestStatus, ApplyGeneratedProposalOptions, ApplyGeneratedProposalResult, ArchiveAgentAliasEverywhereResult, ArchiveAgentAliasInput, AttachRuntimeToolsOptions, BatchClient, BatchListParams, BatchOptions, BatchRequest, BatchResult, BatchScheduleConfig, BatchStatus, BindSkillInput, BuiltInGraderId, CaseExpected, CheckGrader, ClaimApiKeyRequestInput, ClaimApiKeyRequestResponse, ClientConversation, ClientToken, ClientTokenConfig, ClientTokenDefinition, ClientTokenEnvironment, ClientTokenVersionPin, ClientWidgetTheme, ConditionalGetResult, ConditionalStepConfig, ContextErrorHandling, ContextFallback, CreateApiKeyRequestInput, CreateApiKeyRequestResponse, CreateClientTokenRequest, CreateClientTokenResponse, CreateEvalSuiteInput, CreatePromptData, DecomposeCriteriaResult, DefineAgentInput, DefineEvalCaseInput, DefineEvalInput, DefineFlowInput, DefineProductInput, DefineSkillInput, DefineSurfaceInput, DefineToolInput, DetachedReattach, DetachedReconnectOptions, DispatchClient, DispatchEvent, DispatchOptions, EnsureAgentConverged, EnsureAgentOptions, EnsureAgentPlan, EnsureAgentResult, EnsureClientTokenConverged, EnsureClientTokenOptions, EnsureClientTokenPlan, EnsureClientTokenResult, EnsureEvalResult, EnsureFlowConverged, EnsureFlowOptions, EnsureFlowPlan, EnsureFlowResult, EnsureFpoOptions, EnsureFpoResult, EnsureProductConverged, EnsureProductOptions, EnsureProductPlan, EnsureProductResult, EnsureSkillConverged, EnsureSkillOptions, EnsureSkillPlan, EnsureSkillResult, EnsureSurfaceConverged, EnsureSurfaceOptions, EnsureSurfacePlan, EnsureSurfaceResult, EnsureToolConverged, EnsureToolOptions, EnsureToolPlan, EnsureToolResult, ErrorHandlingMode, EvalAgentSelector, EvalAgentTargetResolution, EvalCaseDefinition, EvalCaseInput, EvalCaseProposal, EvalCaseProposalAccepted, EvalCaseProposalListResult, EvalCasesGenerated, EvalClient, EvalDefinition, EvalListParams, EvalMessage, EvalOptions, EvalProposalSource, EvalProposalStatus, EvalProposedCase, EvalPullResult, EvalRecord, EvalRequest, EvalResult, EvalRunCaseScores, EvalRunConfig, EvalRunEvidence, EvalRunScores, EvalStatus, EvalSuiteCase, EvalSuiteCaseInput, EvalSuiteCoverage, EvalSuiteDetail, EvalSuiteLatestRun, EvalSuiteListResult, EvalSuiteRunQueued, EvalSuiteRunResult, EvalSuiteSummary, EvalTarget, ExecutionStreamEvent, FallbackFailEvent, FallbackStartEvent, FallbackSuccessEvent, FallbackTrigger, FallbackTriggerType, FallbacksExhaustedEvent, FallbacksInitiatedEvent, FetchUrlStepConfig, FieldFormat, FlowCompleteEvent, FlowConfig, FlowDefinition, FlowDefinitionStep, FlowErrorEvent, FlowFallback, FlowInlineEvalInput, FlowPausedEvent, FlowPullResult, FlowStartEvent, FlowStreamEvent, FlowSummary, FlowValidationClient, FlowValidationIssue, FlowValidationResult, FpoEntityOutcome, FpoInput, GenerateEmbeddingStepConfig, GenerateEvalCasesInput, GeneratedRuntimeToolGateDecision, GeneratedRuntimeToolGateOptions, GetApiKeyRequestResponse, GetRecordStepConfig, Gradeable, GraderConfig, GraderOutcome, GraderSeverity, HumanVerdict, ListAgentAliasesOptions, ListAgentDeploymentsOptions, ListConversationsResponse, ListRecordsStepConfig, LoopStepConfig, Message, MessageFallback, ModelFallback, ModelOverride, OrganizationAgentAlias, OrganizationAgentAliasList, PersistedGraderOutcome, PrepareAgentPromotionInput, ProductDefinition, ProductPullResult, PromoteAgentInput, PromoteAgentResult, PromptErrorHandling, PromptFallback, PromptListParams, PromptStepConfig, PullFpoResult, RecordConfig, RecordFilter, RecordFilterCondition, RecordFilterGroup, RecordFilterOperator, RetrieveRecordStepConfig, RetryFallback, RollbackAgentAliasInput, RunEvalCaseResult, RunEvalInput, RunEvalResult, RunListParams, RunListResponse, RunListRow, AgentSkillBinding as RuntypeAgentSkillBinding, ConditionalStepConfig$1 as RuntypeConditionalStepConfig, RuntypeConfig, FetchUrlStepConfig$1 as RuntypeFetchUrlStepConfig, FlowConfig$1 as RuntypeFlowConfig, GenerateEmbeddingStepConfig$1 as RuntypeGenerateEmbeddingStepConfig, GetRecordStepConfig$1 as RuntypeGetRecordStepConfig, ListRecordsStepConfig$1 as RuntypeListRecordsStepConfig, LoopStepConfig$1 as RuntypeLoopStepConfig, Message$1 as RuntypeMessage, ModelOverride$1 as RuntypeModelOverride, Prompt$1 as RuntypePrompt, PromptStepConfig$1 as RuntypePromptStepConfig, RecordConfig$1 as RuntypeRecordConfig, RetrieveRecordStepConfig$1 as RuntypeRetrieveRecordStepConfig, SearchStepConfig as RuntypeSearchStepConfig, SendEmailStepConfig as RuntypeSendEmailStepConfig, SendEventStepConfig as RuntypeSendEventStepConfig, SendStreamStepConfig as RuntypeSendStreamStepConfig, SetVariableStepConfig as RuntypeSetVariableStepConfig, Skill as RuntypeSkill, SkillBindingWithAgent as RuntypeSkillBindingWithAgent, SkillCapabilities as RuntypeSkillCapabilities, SkillFrontmatter as RuntypeSkillFrontmatter, SkillManifest as RuntypeSkillManifest, SkillProposal as RuntypeSkillProposal, SkillRuntypeExtensions as RuntypeSkillRuntypeExtensions, SkillVersion as RuntypeSkillVersion, TransformDataStepConfig as RuntypeTransformDataStepConfig, UpsertFlowConfig as RuntypeUpsertFlowConfig, UpsertRecordStepConfig as RuntypeUpsertRecordStepConfig, VectorSearchStepConfig as RuntypeVectorSearchStepConfig, WaitUntilStepConfig as RuntypeWaitUntilStepConfig, SearchStepConfig$1 as SearchStepConfig, SendEmailStepConfig$1 as SendEmailStepConfig, SendEventStepConfig$1 as SendEventStepConfig, SendStreamStepConfig$1 as SendStreamStepConfig, SetVariableStepConfig$1 as SetVariableStepConfig, SkillDefinition, SkillListPage, SkillListPagination, SkillListParams, SkillManifestInput, SkillMarkdownInput, SkillOrigin, SkillProposalStatus, SkillPullResult, SkillStatus, SkillTrustLevel, SkillVersionStatus, SkillWithVersion, SkillWriteInput, StepCompleteEvent, StepDeltaEvent, StepFallback, StepFieldMeta, StepStartEvent, StepWaitingLocalEvent, StreamCallbacks, StreamConsumeOptions, StreamEvent, StreamEventOf, SurfaceDefinition, SurfaceDefinitionStatus, SurfaceDefinitionType, SurfacePullResult, ToolDefinition, ToolDefinitionType, ToolPullResult, TransformDataStepConfig$1 as TransformDataStepConfig, UpdateClientTokenRequest, UpdateEvalCaseInput, UpdateEvalSuiteInput, UpdatePromptData, UpsertFlowConfig$1 as UpsertFlowConfig, UpsertRecordStepConfig$1 as UpsertRecordStepConfig, ValidateAgentPromotionInput, VectorSearchStepConfig$1 as VectorSearchStepConfig, WaitUntilStepConfig$1 as WaitUntilStepConfig, WorkflowCompileDeps, WorkflowCompletionCriteriaConfig, WorkflowConfig, WorkflowConfigFactory, WorkflowHookEntry, WorkflowHookKind, WorkflowHookRef, WorkflowHookSignatures, WorkflowMilestoneConfig, WorkflowPolicyConfig, WorkflowRecoveryConfig, WorkflowSlot };
+export type { AIGrader, ActivateAgentAliasInput, ActivateAgentPromotionInput, AgentAlias, AgentAliasActivation, AgentAliasArchiveFailure, AgentAliasArchived, AgentAliasList, AgentAliasTransport, AgentCapabilityChange, AgentCapabilityDeclaration, AgentDefinition, AgentDefinitionConfig, AgentDeploymentList, AgentDeploymentPromotion, AgentDeploymentReceipt, AgentPromotionManifest, AgentPromotionTransport, AgentPromotionValidation, AgentPullResult, AgentSkillBinding, AgentSkillBindingChange, AgentStreamEvent, ApiKeyRequest, ApiKeyRequestDelivery, ApiKeyRequestEnvironment, ApiKeyRequestHandoff, ApiKeyRequestListParams, ApiKeyRequestRequester, ApiKeyRequestStatus, ApplyGeneratedProposalOptions, ApplyGeneratedProposalResult, ArchiveAgentAliasEverywhereResult, ArchiveAgentAliasInput, AttachRuntimeToolsOptions, BatchClient, BatchListParams, BatchOptions, BatchRequest, BatchResult, BatchScheduleConfig, BatchStatus, BindSkillInput, BuiltInGraderId, CaseExpected, CheckGrader, ClaimApiKeyRequestInput, ClaimApiKeyRequestResponse, ClientConversation, ClientToken, ClientTokenConfig, ClientTokenDefinition, ClientTokenEnvironment, ClientTokenVersionPin, ClientWidgetTheme, CollectionPullResult, CollectionSchemaChange, ConditionalGetResult, ConditionalStepConfig, ContextErrorHandling, ContextFallback, CreateApiKeyRequestInput, CreateApiKeyRequestResponse, CreateClientTokenRequest, CreateClientTokenResponse, CreateEvalSuiteInput, CreatePromptData, DecomposeCriteriaResult, DefineAgentInput, DefineEvalCaseInput, DefineEvalInput, DefineFlowInput, DefineProductInput, DefineScheduleInput, DefineSkillInput, DefineSurfaceInput, DefineToolInput, DetachedReattach, DetachedReconnectOptions, DispatchClient, DispatchEvent, DispatchOptions, EnsureAgentConverged, EnsureAgentOptions, EnsureAgentPlan, EnsureAgentResult, EnsureClientTokenConverged, EnsureClientTokenOptions, EnsureClientTokenPlan, EnsureClientTokenResult, EnsureCollectionConverged, EnsureCollectionOptions, EnsureCollectionPlan, EnsureCollectionResult, EnsureEvalApplyOptions, EnsureEvalOptions, EnsureEvalPlan, EnsureEvalResult, EnsureFlowConverged, EnsureFlowOptions, EnsureFlowPlan, EnsureFlowResult, EnsureFpoOptions, EnsureFpoResult, EnsureProductConverged, EnsureProductOptions, EnsureProductPlan, EnsureProductResult, EnsureQuestionSetConverged, EnsureQuestionSetOptions, EnsureQuestionSetPlan, EnsureQuestionSetResult, EnsureScheduleConverged, EnsureScheduleOptions, EnsureSchedulePlan, EnsureScheduleResult, EnsureSkillConverged, EnsureSkillOptions, EnsureSkillPlan, EnsureSkillResult, EnsureSurfaceConverged, EnsureSurfaceOptions, EnsureSurfacePlan, EnsureSurfaceResult, EnsureToolConverged, EnsureToolOptions, EnsureToolPlan, EnsureToolResult, ErrorHandlingMode, EvalAgentSelector, EvalAgentTargetResolution, EvalCaseDefinition, EvalCaseInput, EvalCaseProposal, EvalCaseProposalAccepted, EvalCaseProposalListResult, EvalCasesGenerated, EvalClient, EvalDefinition, EvalListParams, EvalMessage, EvalOptions, EvalProposalSource, EvalProposalStatus, EvalProposedCase, EvalPullResult, EvalRecord, EvalRequest, EvalResult, EvalRunCaseScores, EvalRunConfig, EvalRunEvidence, EvalRunScores, EvalStatus, EvalSuiteCase, EvalSuiteCaseInput, EvalSuiteCoverage, EvalSuiteDetail, EvalSuiteLatestRun, EvalSuiteListResult, EvalSuiteRunQueued, EvalSuiteRunResult, EvalSuiteSummary, EvalTarget, ExecutionStreamEvent, FallbackFailEvent, FallbackStartEvent, FallbackSuccessEvent, FallbackTrigger, FallbackTriggerType, FallbacksExhaustedEvent, FallbacksInitiatedEvent, FetchUrlStepConfig, FieldFormat, FlowCompleteEvent, FlowConfig, FlowDefinition, FlowDefinitionStep, FlowErrorEvent, FlowFallback, FlowInlineEvalInput, FlowPausedEvent, FlowPullResult, FlowStartEvent, FlowStreamEvent, FlowSummary, FlowValidationClient, FlowValidationIssue, FlowValidationResult, FpoEntityOutcome, FpoInput, GenerateEmbeddingStepConfig, GenerateEvalCasesInput, GeneratedRuntimeToolGateDecision, GeneratedRuntimeToolGateOptions, GetApiKeyRequestResponse, GetRecordStepConfig, Gradeable, GraderConfig, GraderOutcome, GraderSeverity, HumanVerdict, ListAgentAliasesOptions, ListAgentDeploymentsOptions, ListConversationsResponse, ListRecordsStepConfig, LoopStepConfig, Message, MessageFallback, ModelFallback, ModelOverride, OrganizationAgentAlias, OrganizationAgentAliasList, PersistedGraderOutcome, PrepareAgentPromotionInput, ProductDefinition, ProductPullResult, PromoteAgentInput, PromoteAgentResult, PromptErrorHandling, PromptFallback, PromptListParams, PromptStepConfig, PullFpoResult, QuestionSetDefinition, QuestionSetPullResult, RecordCollectionDefinition, RecordCollectionValidationMode, RecordConfig, RecordFilter, RecordFilterCondition, RecordFilterGroup, RecordFilterOperator, RetrieveRecordStepConfig, RetryFallback, RollbackAgentAliasInput, RunEvalCaseResult, RunEvalInput, RunEvalResult, RunListParams, RunListResponse, RunListRow, AgentSkillBinding$1 as RuntypeAgentSkillBinding, ConditionalStepConfig$1 as RuntypeConditionalStepConfig, RuntypeConfig, FetchUrlStepConfig$1 as RuntypeFetchUrlStepConfig, FlowConfig$1 as RuntypeFlowConfig, GenerateEmbeddingStepConfig$1 as RuntypeGenerateEmbeddingStepConfig, GetRecordStepConfig$1 as RuntypeGetRecordStepConfig, ListRecordsStepConfig$1 as RuntypeListRecordsStepConfig, LoopStepConfig$1 as RuntypeLoopStepConfig, Message$1 as RuntypeMessage, ModelOverride$1 as RuntypeModelOverride, Prompt$1 as RuntypePrompt, PromptStepConfig$1 as RuntypePromptStepConfig, RecordConfig$1 as RuntypeRecordConfig, RetrieveRecordStepConfig$1 as RuntypeRetrieveRecordStepConfig, SearchStepConfig as RuntypeSearchStepConfig, SendEmailStepConfig as RuntypeSendEmailStepConfig, SendEventStepConfig as RuntypeSendEventStepConfig, SendStreamStepConfig as RuntypeSendStreamStepConfig, SetVariableStepConfig as RuntypeSetVariableStepConfig, Skill as RuntypeSkill, SkillBindingWithAgent as RuntypeSkillBindingWithAgent, SkillCapabilities as RuntypeSkillCapabilities, SkillFrontmatter as RuntypeSkillFrontmatter, SkillManifest as RuntypeSkillManifest, SkillProposal as RuntypeSkillProposal, SkillRuntypeExtensions as RuntypeSkillRuntypeExtensions, SkillVersion as RuntypeSkillVersion, TransformDataStepConfig as RuntypeTransformDataStepConfig, UpsertFlowConfig as RuntypeUpsertFlowConfig, UpsertRecordStepConfig as RuntypeUpsertRecordStepConfig, VectorSearchStepConfig as RuntypeVectorSearchStepConfig, WaitUntilStepConfig as RuntypeWaitUntilStepConfig, ScheduleDefinition, ScheduleDefinitionMessage, ScheduleEnsureTransport, SchedulePullResult, SearchStepConfig$1 as SearchStepConfig, SendEmailStepConfig$1 as SendEmailStepConfig, SendEventStepConfig$1 as SendEventStepConfig, SendStreamStepConfig$1 as SendStreamStepConfig, SetVariableStepConfig$1 as SetVariableStepConfig, SkillDefinition, SkillListPage, SkillListPagination, SkillListParams, SkillManifestInput, SkillMarkdownInput, SkillOrigin, SkillProposalStatus, SkillPullResult, SkillStatus, SkillTrustLevel, SkillVersionStatus, SkillWithVersion, SkillWriteInput, StepCompleteEvent, StepDeltaEvent, StepFallback, StepFieldMeta, StepStartEvent, StepWaitingLocalEvent, StreamCallbacks, StreamConsumeOptions, StreamEvent, StreamEventOf, SurfaceDefinition, SurfaceDefinitionStatus, SurfaceDefinitionType, SurfacePullResult, ToolDefinition, ToolDefinitionType, ToolPullResult, TransformDataStepConfig$1 as TransformDataStepConfig, UpdateClientTokenRequest, UpdateEvalCaseInput, UpdateEvalSuiteInput, UpdatePromptData, UpsertFlowConfig$1 as UpsertFlowConfig, UpsertRecordStepConfig$1 as UpsertRecordStepConfig, ValidateAgentPromotionInput, VectorSearchStepConfig$1 as VectorSearchStepConfig, WaitUntilStepConfig$1 as WaitUntilStepConfig, WorkflowCompileDeps, WorkflowCompletionCriteriaConfig, WorkflowConfig, WorkflowConfigFactory, WorkflowHookEntry, WorkflowHookKind, WorkflowHookRef, WorkflowHookSignatures, WorkflowMilestoneConfig, WorkflowPolicyConfig, WorkflowRecoveryConfig, WorkflowSlot };
 export {}