@vectros-ai/cli 0.26.0 → 0.27.0

package/dist/cli.js

@@ -521,8 +521,8 @@ var require_graceful_fs = __commonJS({
       fs5.createReadStream = createReadStream3;
       fs5.createWriteStream = createWriteStream;
       var fs$readFile = fs5.readFile;
-      fs5.readFile = readFile4;
-      function readFile4(path4, options, cb) {
+      fs5.readFile = readFile5;
+      function readFile5(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path4, options, cb);
@@ -1614,7 +1614,7 @@ var require_proper_lockfile = __commonJS({
 // src/cli-bootstrap.ts
 var readline2 = __toESM(require("readline/promises"));
 
-// ../../node_modules/@vectros-ai/sdk/dist/index.mjs
+// node_modules/@vectros-ai/sdk/dist/index.mjs
 var __defProp2 = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -1635,6 +1635,7 @@ __export(api_exports, {
   ContentTooLargeError: () => ContentTooLargeError,
   DocumentAskRequest: () => DocumentAskRequest,
   DocumentContextEvent: () => DocumentContextEvent,
+  DocumentExtraction: () => DocumentExtraction,
   DocumentLookupRequest: () => DocumentLookupRequest,
   DocumentPatchRequest: () => DocumentPatchRequest,
   DocumentRequest: () => DocumentRequest,
@@ -1687,6 +1688,7 @@ __export(api_exports, {
   UserExistsResponse: () => UserExistsResponse,
   UserRequest: () => UserRequest,
   UserResponse: () => UserResponse,
+  agents: () => agents_exports,
   auth: () => auth_exports,
   compliance: () => compliance_exports,
   documents: () => documents_exports,
@@ -1952,6 +1954,7 @@ var UnprocessableEntityError = class extends VectrosError {
     this.name = this.constructor.name;
   }
 };
+var agents_exports = {};
 var auth_exports = {};
 var ErasureRequest;
 ((ErasureRequest2) => {
@@ -2156,6 +2159,18 @@ var DocumentContextEvent;
     DocumentContext: "document_context"
   };
 })(DocumentContextEvent || (DocumentContextEvent = {}));
+var DocumentExtraction;
+((DocumentExtraction2) => {
+  DocumentExtraction2.Outcome = {
+    Ok: "OK",
+    Truncated: "TRUNCATED",
+    NoText: "NO_TEXT",
+    Encrypted: "ENCRYPTED",
+    Unsupported: "UNSUPPORTED",
+    TooLarge: "TOO_LARGE",
+    Unreadable: "UNREADABLE"
+  };
+})(DocumentExtraction || (DocumentExtraction = {}));
 var DocumentRequest;
 ((DocumentRequest2) => {
   DocumentRequest2.IndexMode = {
@@ -4024,24 +4039,32 @@ function handleNonStatusCodeError(error, rawResponse, method, path4) {
       });
   }
 }
-var AuthClient = class {
+var AgentsClient = class {
   constructor(options) {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns the platform's JWT signing public key in RFC 7517 JWKS format. Use it with any JWKS-aware JWT library to verify `inv_*` invite tokens, `st_*` scoped tokens, and other platform-signed tokens locally, without calling back to the API for each verification. The response carries a one-hour `Cache-Control`, so cache it and re-fetch roughly hourly rather than on every verification. The `kid` value changes when the key rotates; re-fetch this document whenever you encounter a token signed with an unknown `kid`.
+   * Returns a page of the agents in the app context, newest first, each at its latest version. A caller holding `runs:c` but not `agents:r` gets only each agent's `id`, `name`, `description`, `latestVersion` and `status`. Retired and purged agents are left out unless `includeRetired=true`. Requires `agents:r` or `runs:c`.
    *
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.ListAgentsRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
-   * @throws {@link Vectros.InternalServerError}
+   * @throws {@link Vectros.ForbiddenError}
    *
    * @example
-   *     await client.auth.getJwks()
+   *     await client.agents.listAgents()
    */
-  getJwks(requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__getJwks(requestOptions));
+  listAgents(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listAgents(request, requestOptions));
   }
-  async __getJwks(requestOptions) {
+  async __listAgents(request = {}, requestOptions) {
+    const { contextId, includeRetired, startFrom, limit } = request;
+    const _queryParams = {
+      contextId,
+      includeRetired,
+      startFrom,
+      limit
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -4051,11 +4074,11 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "v1/auth/jwks"
+        "v1/agents"
       ),
       method: "GET",
       headers: _headers,
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -4067,8 +4090,8 @@ var AuthClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
-        case 500:
-          throw new InternalServerError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4077,59 +4100,34 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/auth/jwks");
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/agents");
   }
   /**
-   * Returns a page of per-subject PHI read-access rows: who read which subject's PHI, when, against which record, and whether any sensitive value was actually revealed in plaintext. Metadata only — never the PHI itself. Rows exist only where read-access logging is enabled. Provide at least one query axis: a subject (`subjectType` + `subjectId`) within a `contextId` for the primary accounting query; `resourceId` within a `contextId` for 'who read this record'; `callerKeyId` for 'what did this credential read' (account-wide forensic); or `contextId` alone to enumerate a whole context. `from`/`to` bound the time window. Results are scoped to your account, derived from your token — never from input. Requires the `access-log:r` scope.
+   * Stores a new agent at version 1, or returns the existing agent of this name unchanged. With `?upsert=true` an existing agent whose definition differs gets a new version instead. Requires the `agents:c` scope (also `agents:u` with `?upsert=true`).
    *
-   * @param {Vectros.GetAccessLogRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.CreateAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
-   *     await client.auth.getAccessLog({
-   *         subjectType: "user",
-   *         subjectId: "user_abc123",
-   *         contextId: "ctx_intake",
-   *         action: "read",
-   *         callerKeyId: "key_abc123",
-   *         resourceType: "intake_form",
-   *         resourceId: "rec_456"
+   *     await client.agents.createAgent({
+   *         body: {
+   *             model: "claude-sonnet-5-5"
+   *         }
    *     })
    */
-  getAccessLog(request = {}, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__getAccessLog(request, requestOptions));
+  createAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createAgent(request, requestOptions));
   }
-  async __getAccessLog(request = {}, requestOptions) {
-    const {
-      subjectType,
-      subjectId,
-      contextId,
-      from: from_,
-      to,
-      action,
-      callerKeyId,
-      resourceType,
-      resourceId,
-      revealedSensitive,
-      startFrom,
-      limit
-    } = request;
+  async __createAgent(request, requestOptions) {
+    const { upsert, contextId, body: _body } = request;
     const _queryParams = {
-      subjectType,
-      subjectId,
-      contextId,
-      from: from_,
-      to,
-      action,
-      callerKeyId,
-      resourceType,
-      resourceId,
-      revealedSensitive,
-      startFrom,
-      limit
+      upsert,
+      contextId
     };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
@@ -4140,11 +4138,14 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "v1/admin/access-log"
+        "v1/agents"
       ),
-      method: "GET",
+      method: "POST",
       headers: _headers,
+      contentType: "application/json",
       queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: _body,
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -4160,6 +4161,10 @@ var AuthClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4168,22 +4173,31 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/access-log");
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/agents");
   }
   /**
-   * Lists your scoped API keys (`ssk_*`) in your credential's own environment — a live key lists live keys, a test key lists test keys. Revoked keys are excluded. Requires the `keys:r` scope.
+   * Returns the agent at its latest version, or at `version`. Requires the `agents:r` scope.
    *
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.GetAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
    *
    * @example
-   *     await client.auth.listScopedKeys()
+   *     await client.agents.getAgent({
+   *         id: "id"
+   *     })
    */
-  listScopedKeys(requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__listScopedKeys(requestOptions));
+  getAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getAgent(request, requestOptions));
   }
-  async __listScopedKeys(requestOptions) {
+  async __getAgent(request, requestOptions) {
+    const { id, contextId, version } = request;
+    const _queryParams = {
+      contextId,
+      version
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -4193,11 +4207,11 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "v1/admin/keys/scoped"
+        `v1/agents/${url_exports.encodePathParam(id)}`
       ),
       method: "GET",
       headers: _headers,
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -4211,6 +4225,8 @@ var AuthClient = class {
       switch (_response.error.statusCode) {
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4219,13 +4235,13 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/keys/scoped");
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/agents/{id}");
   }
   /**
-   * Creates a scoped API key (an `ssk_*` secret) that inherits its permissions from an existing access profile in your account. The call is idempotent on the combination of tenant, context, user, and key name: re-issuing the same request returns the existing key WITHOUT re-disclosing its raw secret. The raw key is returned ONLY in this response — store it securely, as it cannot be retrieved again. Requires the `keys:c` scope. If you use a scoped credential, `keys:c` alone is not sufficient: because the minted key is durably bound to the profile you name, the profile's effective scopes may not exceed your own, and you may only mint against a profile whose `identityOverrides` values your own identity holds. Minting a key bound to your OWN principal needs nothing further; minting one bound to a DIFFERENT principal additionally requires the `delegate-mint` capability (`granted_capabilities`) on your credential — without it the request is refused. A root API key (`sk_`) is exempt from all three bounds. The profile you name must be `active` AND the user you name must not be `SUSPENDED`: either is refused with `409`, and no root exemption applies to that. Both refusals stop ISSUANCE only. Suspending the profile or the user additionally stops credentials already bound to it, within about five minutes. A `PENDING` user is fine.
+   * Stores the body as the agent's next version. Earlier versions never change. Every optional field you leave out takes its default; `model` is required. With `?restore=true` a retired agent becomes active again with this version. Requires the `agents:u` scope.
    *
-   * @param {Vectros.CreateScopedKeyRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.UpdateAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
@@ -4234,17 +4250,22 @@ var AuthClient = class {
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
-   *     await client.auth.createScopedKey({
-   *         keyName: "research-bot production",
-   *         tenantId: "ten_live_xxx",
-   *         contextId: "myapp",
-   *         userId: "alice-001"
+   *     await client.agents.updateAgent({
+   *         id: "id",
+   *         body: {
+   *             model: "claude-sonnet-5-5"
+   *         }
    *     })
    */
-  createScopedKey(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__createScopedKey(request, requestOptions));
+  updateAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__updateAgent(request, requestOptions));
   }
-  async __createScopedKey(request, requestOptions) {
+  async __updateAgent(request, requestOptions) {
+    const { id, restore, contextId, body: _body } = request;
+    const _queryParams = {
+      restore,
+      contextId
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -4254,14 +4275,14 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "v1/admin/keys/scoped"
+        `v1/agents/${url_exports.encodePathParam(id)}`
       ),
-      method: "POST",
+      method: "PUT",
       headers: _headers,
       contentType: "application/json",
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       requestType: "json",
-      body: request,
+      body: _body,
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -4291,27 +4312,35 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/admin/keys/scoped");
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/agents/{id}");
   }
   /**
-   * Returns the metadata for a single scoped API key. The raw secret is NOT included — it is only ever returned once, when the key is first created. Requires the `keys:r` scope.
+   * Retires the agent: its versions stay readable, it leaves the default listing, and it can be restored. With `?purge=true` a retired agent's content (every version's prompt, description, tools, model, limits and budget) is erased, leaving its id, name, version numbers and timestamps; its change history keeps only a one-way hash of the prompt, description and tools. If the agent is restored while a purge is running, the purge stops (409) and versions it already erased stay erased; purge it again after retiring it. With `?purge=true&version=N` one version that is not the latest is erased. The name of a purged agent stays reserved. Requires the `agents:d` scope.
    *
-   * @param {Vectros.GetScopedKeyRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.DeleteAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
-   *     await client.auth.getScopedKey({
-   *         keyId: "keyId"
+   *     await client.agents.deleteAgent({
+   *         id: "id"
    *     })
    */
-  getScopedKey(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__getScopedKey(request, requestOptions));
+  deleteAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__deleteAgent(request, requestOptions));
   }
-  async __getScopedKey(request, requestOptions) {
-    const { keyId } = request;
+  async __deleteAgent(request, requestOptions) {
+    const { id, purge, version, contextId } = request;
+    const _queryParams = {
+      purge,
+      version,
+      contextId
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -4321,11 +4350,11 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        `v1/admin/keys/scoped/${url_exports.encodePathParam(keyId)}`
+        `v1/agents/${url_exports.encodePathParam(id)}`
       ),
-      method: "GET",
+      method: "DELETE",
       headers: _headers,
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -4337,10 +4366,16 @@ var AuthClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4349,28 +4384,33 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/keys/scoped/{keyId}");
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/agents/{id}");
   }
   /**
-   * Revokes a scoped API key. Its status changes to `revoked` and it stops working within about 5 minutes, the maximum time authorization is cached. Revocation is permanent. Requires the `keys:d` scope.
+   * Returns a page of the agent's versions, newest first: who wrote each and when, and whether it was purged. With `includeContent=true` each entry carries its full definition. Requires the `agents:r` scope.
    *
-   * @param {Vectros.RevokeScopedKeyRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.ListAgentVersionsRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
-   * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
-   *     await client.auth.revokeScopedKey({
-   *         keyId: "keyId"
+   *     await client.agents.listAgentVersions({
+   *         id: "id"
    *     })
    */
-  revokeScopedKey(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__revokeScopedKey(request, requestOptions));
+  listAgentVersions(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listAgentVersions(request, requestOptions));
   }
-  async __revokeScopedKey(request, requestOptions) {
-    const { keyId } = request;
+  async __listAgentVersions(request, requestOptions) {
+    const { id, contextId, includeContent, startFrom, limit } = request;
+    const _queryParams = {
+      contextId,
+      includeContent,
+      startFrom,
+      limit
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -4380,11 +4420,11 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        `v1/admin/keys/scoped/${url_exports.encodePathParam(keyId)}`
+        `v1/agents/${url_exports.encodePathParam(id)}/versions`
       ),
-      method: "DELETE",
+      method: "GET",
       headers: _headers,
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -4392,7 +4432,7 @@ var AuthClient = class {
       logging: this._options.logging
     });
     if (_response.ok) {
-      return { data: void 0, rawResponse: _response.rawResponse };
+      return { data: _response.body, rawResponse: _response.rawResponse };
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
@@ -4400,8 +4440,6 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
-        case 429:
-          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4410,45 +4448,32 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(
-      _response.error,
-      _response.rawResponse,
-      "DELETE",
-      "/v1/admin/keys/scoped/{keyId}"
-    );
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/agents/{id}/versions");
   }
   /**
-   * Returns recent API call logs for your account. Each entry represents one API request; request and response bodies are never logged. `startTime` and `endTime` must be ISO-8601 UTC (e.g. `2025-01-15T09:00:00Z`); `endTime` defaults to now. Filter by resource, method, key id, or context id, or set `errorsOnly` to see only failures. Results are scoped to your account, derived from your token — never from input. Requires the `logs:r` scope.
+   * Stops a run. The answer is `202` with the run still `RUNNING`: read it with `GET /v1/runs/{id}` to see it end. A model call in progress is cut within a few seconds; a tool call in progress is first allowed to finish, for up to about 30 seconds, so its change is recorded and billed, and the run stops as soon as it has. The run then ends `CANCELLED` with `errorCode` `CANCELLED_BY_CALLER`, unless it had already completed, in which case it stays `COMPLETED`. Its reservation is settled once, like any run's: a model call in progress when it stopped is charged up to its maximum. A run that has ended (or that had not started, which this cancel ends) answers `200` with its final state, so a cancel can always be retried. A run can be cancelled by the credential that started it (for a token bound to a user, by that user) and by your root key. Requires the `runs:c` scope; with `runs:r` as well the answer is the whole run, otherwise only its `id`, `status`, `terminal`, `reason` and `errorCode`. Takes no body.
    *
-   * @param {Vectros.GetAdminLogsRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.CancelRunRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.UnauthorizedError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
-   *     await client.auth.getAdminLogs({
-   *         startTime: "startTime",
-   *         resource: "documents",
-   *         method: "POST",
-   *         keyId: "key_abc123",
-   *         contextId: "ctx_intake"
+   *     await client.agents.cancelRun({
+   *         id: "id"
    *     })
    */
-  getAdminLogs(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__getAdminLogs(request, requestOptions));
+  cancelRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__cancelRun(request, requestOptions));
   }
-  async __getAdminLogs(request, requestOptions) {
-    const { startTime, endTime, resource, method, keyId, contextId, errorsOnly, limit } = request;
+  async __cancelRun(request, requestOptions) {
+    const { id, contextId } = request;
     const _queryParams = {
-      startTime,
-      endTime,
-      resource,
-      method,
-      keyId,
-      contextId,
-      errorsOnly,
-      limit
+      contextId
     };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
@@ -4459,9 +4484,9 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "v1/admin/logs"
+        `v1/runs/${url_exports.encodePathParam(id)}/cancel`
       ),
-      method: "GET",
+      method: "POST",
       headers: _headers,
       queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
@@ -4477,8 +4502,14 @@ var AuthClient = class {
       switch (_response.error.statusCode) {
         case 400:
           throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4487,30 +4518,31 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/logs");
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/runs/{id}/cancel");
   }
   /**
-   * Returns the access profiles assigned within the given app context — in effect, who has access to this context and with what scopes. Each profile binds a principal to either a set of inline scopes or a referenced role. Results are paginated. Requires the `profiles:r` scope.
+   * Returns the status and metadata of one run: the agent version that ran, how it ended, its tool calls (never their arguments or results) and what it was charged. It never returns text: the answer is delivered only in the run's stream. A run is visible to the credential that started it (for a token bound to a user, to that user) and to your root key, and is kept for 30 days after it ends. Requires the `runs:r` scope.
    *
-   * @param {Vectros.ListAccessProfilesRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Vectros.GetRunRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.UnauthorizedError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
    *
    * @example
-   *     await client.auth.listAccessProfiles({
-   *         contextId: "myapp"
+   *     await client.agents.getRun({
+   *         id: "id"
    *     })
    */
-  listAccessProfiles(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__listAccessProfiles(request, requestOptions));
+  getRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getRun(request, requestOptions));
   }
-  async __listAccessProfiles(request, requestOptions) {
-    const { contextId, startFrom, limit } = request;
+  async __getRun(request, requestOptions) {
+    const { id, contextId } = request;
     const _queryParams = {
-      startFrom,
-      limit
+      contextId
     };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
@@ -4521,7 +4553,7 @@ var AuthClient = class {
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        `v1/app-contexts/${url_exports.encodePathParam(contextId)}/profiles`
+        `v1/runs/${url_exports.encodePathParam(id)}`
       ),
       method: "GET",
       headers: _headers,
@@ -4537,6 +4569,10 @@ var AuthClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
@@ -4549,31 +4585,635 @@ var AuthClient = class {
           });
       }
     }
-    return handleNonStatusCodeError(
-      _response.error,
-      _response.rawResponse,
-      "GET",
-      "/v1/app-contexts/{contextId}/profiles"
-    );
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/runs/{id}");
   }
   /**
-   * Creates a new access profile under the given app context. This call is idempotent by `principalId`: if a profile with the same `principalId` already exists, the existing profile is returned (with status 200) instead of creating a duplicate. The response's `created` field (and the HTTP status — 201 when created, 200 when an existing profile was returned) tells the two apart. To overwrite an existing profile's `scopes`/`roleId`, `identityOverrides`, and `status` instead of returning it unchanged, set `?upsert=true` (this also requires the `profiles:u` scope, and applies the same `identityOverrides` bounds the update endpoint documents — a scoped credential may not repoint or clear an identity value it does not itself hold). The `principalId` must name a principal that already exists: a `usr_` principal must be a live user in your tenant, so create the user before granting it a profile. A `usr_` id that names no such user is rejected, and no profile is created. `key_` principals are not checked this way. You must provide exactly one of `scopes` (an inline list of scopes) or `roleId` (a reference to a role); supplying both, or neither, is rejected. `identityOverrides` is keyed by ownership namespace in `scope:<namespace>` form — `scope:org` and `scope:client` for the reserved namespaces, or any namespace you have registered — and may name at most two; any other key (including the account identifier or `userId`) is rejected. If you use a scoped credential, the profile's effective scopes may not exceed your own; a root API key (`sk_`) is exempt. Requires the `profiles:c` scope.
-   *
-   * @param {Vectros.CreateAccessProfileRequest} request
-   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
-   *
-   * @throws {@link Vectros.BadRequestError}
-   * @throws {@link Vectros.ForbiddenError}
-   * @throws {@link Vectros.NotFoundError}
-   * @throws {@link Vectros.ConflictError}
-   * @throws {@link Vectros.TooManyRequestsError}
-   *
-   * @example
+   * Starts a run of a stored agent and streams what it does as Server-Sent Events. The response is always `text/event-stream`, whatever `Accept` you send; its `X-Vectros-Run-Id` header names the run. The run's tool calls act as you, with your own permissions, and only through the tools the agent lists. On a prepaid account the run reserves its budget from your inference balance when it starts and returns what its model calls did not use when it ends; a fixed fee per run, tool calls and run time are billed separately, against your plan. Read each event's `type`; ignore types and fields you do not know; stop at the event with `terminal: true`. A stream that ends without one: read the run with `GET /v1/runs/{id}`. Closing the stream stops the run only on a best-effort basis. Requires the `runs:c` scope, and agent runs switched on for your tenant by an account owner.
+   */
+  createRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createRun(request, requestOptions));
+  }
+  async __createRun(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/runs"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: _body,
+      responseType: "sse",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: new Stream({
+          stream: _response.body,
+          parse: (data) => data,
+          signal: requestOptions?.abortSignal,
+          eventShape: {
+            type: "sse"
+          }
+        }),
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 402:
+          throw new PaymentRequiredError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 413:
+          throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
+        case 422:
+          throw new UnprocessableEntityError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/runs");
+  }
+};
+var AuthClient = class {
+  constructor(options) {
+    this._options = normalizeClientOptionsWithAuth(options);
+  }
+  /**
+   * Returns the platform's JWT signing public key in RFC 7517 JWKS format. Use it with any JWKS-aware JWT library to verify `inv_*` invite tokens, `st_*` scoped tokens, and other platform-signed tokens locally, without calling back to the API for each verification. The response carries a one-hour `Cache-Control`, so cache it and re-fetch roughly hourly rather than on every verification. The `kid` value changes when the key rotates; re-fetch this document whenever you encounter a token signed with an unknown `kid`.
+   *
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.InternalServerError}
+   *
+   * @example
+   *     await client.auth.getJwks()
+   */
+  getJwks(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getJwks(requestOptions));
+  }
+  async __getJwks(requestOptions) {
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/auth/jwks"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 500:
+          throw new InternalServerError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/auth/jwks");
+  }
+  /**
+   * Returns a page of per-subject PHI read-access rows: who read which subject's PHI, when, against which record, and whether any sensitive value was actually revealed in plaintext. Metadata only — never the PHI itself. Rows exist only where read-access logging is enabled. Provide at least one query axis: a subject (`subjectType` + `subjectId`) within a `contextId` for the primary accounting query; `resourceId` within a `contextId` for 'who read this record'; `callerKeyId` for 'what did this credential read' (account-wide forensic); or `contextId` alone to enumerate a whole context. `from`/`to` bound the time window. Results are scoped to your account, derived from your token — never from input. Requires the `access-log:r` scope.
+   *
+   * @param {Vectros.GetAccessLogRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   *
+   * @example
+   *     await client.auth.getAccessLog({
+   *         subjectType: "user",
+   *         subjectId: "user_abc123",
+   *         contextId: "ctx_intake",
+   *         action: "read",
+   *         callerKeyId: "key_abc123",
+   *         resourceType: "intake_form",
+   *         resourceId: "rec_456"
+   *     })
+   */
+  getAccessLog(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getAccessLog(request, requestOptions));
+  }
+  async __getAccessLog(request = {}, requestOptions) {
+    const {
+      subjectType,
+      subjectId,
+      contextId,
+      from: from_,
+      to,
+      action,
+      callerKeyId,
+      resourceType,
+      resourceId,
+      revealedSensitive,
+      startFrom,
+      limit
+    } = request;
+    const _queryParams = {
+      subjectType,
+      subjectId,
+      contextId,
+      from: from_,
+      to,
+      action,
+      callerKeyId,
+      resourceType,
+      resourceId,
+      revealedSensitive,
+      startFrom,
+      limit
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/admin/access-log"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/access-log");
+  }
+  /**
+   * Lists your scoped API keys (`ssk_*`) in your credential's own environment — a live key lists live keys, a test key lists test keys. Revoked keys are excluded. Requires the `keys:r` scope.
+   *
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   *
+   * @example
+   *     await client.auth.listScopedKeys()
+   */
+  listScopedKeys(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listScopedKeys(requestOptions));
+  }
+  async __listScopedKeys(requestOptions) {
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/admin/keys/scoped"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/keys/scoped");
+  }
+  /**
+   * Creates a scoped API key (an `ssk_*` secret) that inherits its permissions from an existing access profile in your account. The call is idempotent on the combination of tenant, context, user, and key name: re-issuing the same request returns the existing key WITHOUT re-disclosing its raw secret. The raw key is returned ONLY in this response — store it securely, as it cannot be retrieved again. Requires the `keys:c` scope. If you use a scoped credential, `keys:c` alone is not sufficient: because the minted key is durably bound to the profile you name, the profile's effective scopes may not exceed your own, and you may only mint against a profile whose `identityOverrides` values your own identity holds. Minting a key bound to your OWN principal needs nothing further; minting one bound to a DIFFERENT principal additionally requires the `delegate-mint` capability (`granted_capabilities`) on your credential — without it the request is refused. A root API key (`sk_`) is exempt from all three bounds. The profile you name must be `active` AND the user you name must not be `SUSPENDED`: either is refused with `409`, and no root exemption applies to that. Both refusals stop ISSUANCE only. Suspending the profile or the user additionally stops credentials already bound to it, within about five minutes. A `PENDING` user is fine.
+   *
+   * @param {Vectros.CreateScopedKeyRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.auth.createScopedKey({
+   *         keyName: "research-bot production",
+   *         tenantId: "ten_live_xxx",
+   *         contextId: "myapp",
+   *         userId: "alice-001"
+   *     })
+   */
+  createScopedKey(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createScopedKey(request, requestOptions));
+  }
+  async __createScopedKey(request, requestOptions) {
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/admin/keys/scoped"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/admin/keys/scoped");
+  }
+  /**
+   * Returns the metadata for a single scoped API key. The raw secret is NOT included — it is only ever returned once, when the key is first created. Requires the `keys:r` scope.
+   *
+   * @param {Vectros.GetScopedKeyRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   *
+   * @example
+   *     await client.auth.getScopedKey({
+   *         keyId: "keyId"
+   *     })
+   */
+  getScopedKey(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getScopedKey(request, requestOptions));
+  }
+  async __getScopedKey(request, requestOptions) {
+    const { keyId } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/admin/keys/scoped/${url_exports.encodePathParam(keyId)}`
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/keys/scoped/{keyId}");
+  }
+  /**
+   * Revokes a scoped API key. Its status changes to `revoked` and it stops working within about 5 minutes, the maximum time authorization is cached. Revocation is permanent. Requires the `keys:d` scope.
+   *
+   * @param {Vectros.RevokeScopedKeyRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.auth.revokeScopedKey({
+   *         keyId: "keyId"
+   *     })
+   */
+  revokeScopedKey(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__revokeScopedKey(request, requestOptions));
+  }
+  async __revokeScopedKey(request, requestOptions) {
+    const { keyId } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/admin/keys/scoped/${url_exports.encodePathParam(keyId)}`
+      ),
+      method: "DELETE",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: void 0, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "DELETE",
+      "/v1/admin/keys/scoped/{keyId}"
+    );
+  }
+  /**
+   * Returns recent API call logs for your account. Each entry represents one API request; request and response bodies are never logged. `startTime` and `endTime` must be ISO-8601 UTC (e.g. `2025-01-15T09:00:00Z`); `endTime` defaults to now. Filter by resource, method, key id, or context id, or set `errorsOnly` to see only failures. Results are scoped to your account, derived from your token — never from input. Requires the `logs:r` scope.
+   *
+   * @param {Vectros.GetAdminLogsRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   *
+   * @example
+   *     await client.auth.getAdminLogs({
+   *         startTime: "startTime",
+   *         resource: "documents",
+   *         method: "POST",
+   *         keyId: "key_abc123",
+   *         contextId: "ctx_intake"
+   *     })
+   */
+  getAdminLogs(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getAdminLogs(request, requestOptions));
+  }
+  async __getAdminLogs(request, requestOptions) {
+    const { startTime, endTime, resource, method, keyId, contextId, errorsOnly, limit } = request;
+    const _queryParams = {
+      startTime,
+      endTime,
+      resource,
+      method,
+      keyId,
+      contextId,
+      errorsOnly,
+      limit
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/admin/logs"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/logs");
+  }
+  /**
+   * Returns the access profiles assigned within the given app context — in effect, who has access to this context and with what scopes. Each profile binds a principal to either a set of inline scopes or a referenced role. Results are paginated. Requires the `profiles:r` scope.
+   *
+   * @param {Vectros.ListAccessProfilesRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   *
+   * @example
+   *     await client.auth.listAccessProfiles({
+   *         contextId: "myapp"
+   *     })
+   */
+  listAccessProfiles(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listAccessProfiles(request, requestOptions));
+  }
+  async __listAccessProfiles(request, requestOptions) {
+    const { contextId, startFrom, limit } = request;
+    const _queryParams = {
+      startFrom,
+      limit
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/app-contexts/${url_exports.encodePathParam(contextId)}/profiles`
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/v1/app-contexts/{contextId}/profiles"
+    );
+  }
+  /**
+   * Creates a new access profile under the given app context. This call is idempotent by `principalId`: if a profile with the same `principalId` already exists, the existing profile is returned (with status 200) instead of creating a duplicate. The response's `created` field (and the HTTP status — 201 when created, 200 when an existing profile was returned) tells the two apart. To overwrite an existing profile's `scopes`/`roleId`, `identityOverrides`, and `status` instead of returning it unchanged, set `?upsert=true` (this also requires the `profiles:u` scope, and applies the same `identityOverrides` bounds the update endpoint documents — a scoped credential may not repoint or clear an identity value it does not itself hold). The `principalId` must name a principal that already exists: a `usr_` principal must be a live user in your tenant, so create the user before granting it a profile. A `usr_` id that names no such user is rejected, and no profile is created. `key_` principals are not checked this way. You must provide exactly one of `scopes` (an inline list of scopes) or `roleId` (a reference to a role); supplying both, or neither, is rejected. `identityOverrides` is keyed by ownership namespace in `scope:<namespace>` form — `scope:org` and `scope:client` for the reserved namespaces, or any namespace you have registered — and may name at most two; any other key (including the account identifier or `userId`) is rejected. If you use a scoped credential, the profile's effective scopes may not exceed your own; a root API key (`sk_`) is exempt. Requires the `profiles:c` scope.
+   *
+   * @param {Vectros.CreateAccessProfileRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
    *     await client.auth.createAccessProfile({
    *         contextId: "contextId",
-   *         body: {
-   *             principalId: "usr_6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-   *         }
+   *         body: {}
    *     })
    */
   createAccessProfile(request, requestOptions) {
@@ -4709,10 +5349,7 @@ var AuthClient = class {
    *
    * @example
    *     await client.auth.createAppContext({
-   *         body: {
-   *             contextId: "myapp",
-   *             name: "My Internal App"
-   *         }
+   *         body: {}
    *     })
    */
   createAppContext(request, requestOptions) {
@@ -4855,13 +5492,7 @@ var AuthClient = class {
    * @example
    *     await client.auth.createRole({
    *         contextId: "contextId",
-   *         body: {
-   *             roleId: "engineering-member",
-   *             name: "Engineering Team Member",
-   *             scopes: [{
-   *                     allowed_actions: ["records:cru", "search:r"]
-   *                 }]
-   *         }
+   *         body: {}
    *     })
    */
   createRole(request, requestOptions) {
@@ -5005,9 +5636,7 @@ var AuthClient = class {
    *     await client.auth.updateAccessProfile({
    *         contextId: "contextId",
    *         principalId: "principalId",
-   *         body: {
-   *             principalId: "usr_6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-   *         }
+   *         body: {}
    *     })
    */
   updateAccessProfile(request, requestOptions) {
@@ -5210,10 +5839,7 @@ var AuthClient = class {
    * @example
    *     await client.auth.updateAppContext({
    *         contextId: "contextId",
-   *         body: {
-   *             contextId: "myapp",
-   *             name: "My Internal App"
-   *         }
+   *         body: {}
    *     })
    */
   updateAppContext(request, requestOptions) {
@@ -5418,13 +6044,7 @@ var AuthClient = class {
    *     await client.auth.updateRole({
    *         contextId: "contextId",
    *         roleId: "roleId",
-   *         body: {
-   *             roleId: "engineering-member",
-   *             name: "Engineering Team Member",
-   *             scopes: [{
-   *                     allowed_actions: ["records:cru", "search:r"]
-   *                 }]
-   *         }
+   *         body: {}
    *     })
    */
   updateRole(request, requestOptions) {
@@ -6876,7 +7496,7 @@ var DocumentsClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns a paginated list of your documents, optionally filtered by folder (`folderId`) and/or owner (`userId` or `scope`). The response is a `{data, nextCursor}` envelope; pass `nextCursor` back as `startFrom` to fetch the next page. Requires the `documents:r` scope.
+   * Returns a paginated list of your documents, optionally filtered by folder (`folderId`), owner (`userId` or `scope`) and/or type (`type`). The response is a `{data, nextCursor}` envelope; pass `nextCursor` back as `startFrom` to fetch the next page. A page can hold fewer documents than `limit`, or none, while `nextCursor` is still set: keep paging until `nextCursor` is null. Requires the `documents:r` scope.
    *
    * @param {Vectros.ListDocumentsRequest} request
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6886,6 +7506,7 @@ var DocumentsClient = class {
    *         userId: "550e8400-e29b-41d4-a716-446655440000",
    *         scope: "group:eng-team",
    *         folderId: "f47ac10b-58cc-4372-a567-0e02b2c3d479",
+   *         type: "investigation_report",
    *         startFrom: "b3BhcXVlLWN1cnNvci1mcm9tLXRoZS1wcmV2aW91cy1wYWdl"
    *     })
    */
@@ -6893,11 +7514,12 @@ var DocumentsClient = class {
     return HttpResponsePromise.fromPromise(this.__listDocuments(request, requestOptions));
   }
   async __listDocuments(request = {}, requestOptions) {
-    const { userId, scope, folderId, startFrom, limit } = request;
+    const { userId, scope, folderId, type: type_, startFrom, limit } = request;
     const _queryParams = {
       userId,
       scope,
       folderId,
+      type: type_,
       startFrom,
       limit
     };
@@ -6947,9 +7569,7 @@ var DocumentsClient = class {
    *
    * @example
    *     await client.documents.ingestDocument({
-   *         body: {
-   *             title: "Patient Intake Form \u2014 Jane Doe"
-   *         }
+   *         body: {}
    *     })
    */
   ingestDocument(request, requestOptions) {
@@ -7079,9 +7699,7 @@ var DocumentsClient = class {
    * @example
    *     await client.documents.updateDocument({
    *         id: "id",
-   *         body: {
-   *             title: "Patient Intake Form \u2014 Jane Doe"
-   *         }
+   *         body: {}
    *     })
    */
   updateDocument(request, requestOptions) {
@@ -7479,11 +8097,12 @@ var DocumentsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/documents/{id}/download");
   }
   /**
-   * Returns the document's full text body when it is retained: retained for text-ingested documents, and for file-uploaded documents unless they were uploaded with `storeText=false` (which discards the extracted text once indexing completes — the original file remains available via `GET /v1/documents/{id}/download`). Returns 404 when the document does not exist, its text was not retained, or extraction has not yet completed. Requires the `documents:r` scope.
+   * Returns the document's full text body when it is retained: retained for text-ingested documents, and for file-uploaded documents unless they were uploaded with `storeText=false` (which discards the extracted text once indexing completes — the original file remains available via `GET /v1/documents/{id}/download`). Returns 404 when the document does not exist, its text was not retained, extraction has not yet completed, or no text could be extracted from its file (see the document's `extraction`). To read a long text in parts, pass `limit` (and `offset` from the second part on): offsets and lengths count Unicode characters (code points), `totalLength` is the length of the whole text, and `nextOffset` is where the next part starts, absent once the end is reached. Requires the `documents:r` scope.
    *
    * @param {Vectros.GetDocumentTextRequest} request
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
    *
    * @example
@@ -7495,7 +8114,11 @@ var DocumentsClient = class {
     return HttpResponsePromise.fromPromise(this.__getDocumentText(request, requestOptions));
   }
   async __getDocumentText(request, requestOptions) {
-    const { id } = request;
+    const { id, offset, limit } = request;
+    const _queryParams = {
+      offset,
+      limit
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -7509,7 +8132,7 @@ var DocumentsClient = class {
       ),
       method: "GET",
       headers: _headers,
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -7521,6 +8144,8 @@ var DocumentsClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
         default:
@@ -7740,9 +8365,7 @@ var FoldersClient = class {
    *
    * @example
    *     await client.folders.createFolder({
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   createFolder(request, requestOptions) {
@@ -7870,9 +8493,7 @@ var FoldersClient = class {
    * @example
    *     await client.folders.updateFolder({
    *         id: "id",
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   updateFolder(request, requestOptions) {
@@ -8005,9 +8626,7 @@ var FoldersClient = class {
    * @example
    *     await client.folders.patchFolder({
    *         id: "id",
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   patchFolder(request, requestOptions) {
@@ -8222,9 +8841,7 @@ var IdentityClient = class {
    *     await client.identity.createEntity({
    *         namespace: "team",
    *         contextId: "myapp",
-   *         body: {
-   *             externalId: "team_eng_platform"
-   *         }
+   *         body: {}
    *     })
    */
   createEntity(request, requestOptions) {
@@ -8360,9 +8977,7 @@ var IdentityClient = class {
    *         namespace: "team",
    *         id: "id",
    *         contextId: "myapp",
-   *         body: {
-   *             externalId: "team_eng_platform"
-   *         }
+   *         body: {}
    *     })
    */
   updateEntity(request, requestOptions) {
@@ -8702,10 +9317,7 @@ var IdentityClient = class {
    * @example
    *     await client.identity.updateNamespace({
    *         namespace: "team",
-   *         body: {
-   *             namespace: "team",
-   *             specificityRank: 1500
-   *         }
+   *         body: {}
    *     })
    */
   updateNamespace(request, requestOptions) {
@@ -8892,10 +9504,7 @@ var IdentityClient = class {
    *
    * @example
    *     await client.identity.registerNamespace({
-   *         body: {
-   *             namespace: "team",
-   *             specificityRank: 1500
-   *         }
+   *         body: {}
    *     })
    */
   registerNamespace(request, requestOptions) {
@@ -9028,9 +9637,7 @@ var IdentityClient = class {
    *
    * @example
    *     await client.identity.createUser({
-   *         body: {
-   *             externalId: "usr_12345"
-   *         }
+   *         body: {}
    *     })
    */
   createUser(request, requestOptions) {
@@ -9149,6 +9756,7 @@ var IdentityClient = class {
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
    * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
@@ -9156,9 +9764,7 @@ var IdentityClient = class {
    * @example
    *     await client.identity.updateUser({
    *         id: "550e8400-e29b-41d4-a716-446655440000",
-   *         body: {
-   *             externalId: "usr_12345"
-   *         }
+   *         body: {}
    *     })
    */
   updateUser(request, requestOptions) {
@@ -9196,6 +9802,8 @@ var IdentityClient = class {
       switch (_response.error.statusCode) {
         case 400:
           throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
         case 409:
@@ -9218,6 +9826,7 @@ var IdentityClient = class {
    * @param {Vectros.DeleteUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
    * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
@@ -9257,6 +9866,8 @@ var IdentityClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
         case 409:
@@ -9461,7 +10072,7 @@ var InferenceClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns the whole platform model catalog, whatever your plan: `availableOn` names each model's plan tiers. Each entry also carries the context window and the credit rates per 1K input and output tokens: `regionPricing.base` for global-region requests, `regionPricing.us` for default requests, and `longContext` for prompts over its threshold. A model reached through a `providerAlias` is not listed. Use this to populate model pickers and to validate a request before calling `/v1/chat`, `/v1/rag`, or `/v1/documents/{id}/ask`.
+   * Returns the whole platform model catalog, whatever your plan: `availableOn` names each model's plan tiers. Each entry also carries the context window and the credit rates per 1K input and output tokens: `regionPricing.base` for global-region requests, `regionPricing.us` for default requests, `longContext` for prompts over its threshold, and `cachePricing` for prompt-cache tokens on a model that has cache prices. A model reached through a `providerAlias` is not listed. Use this to populate model pickers and to validate a request before calling `/v1/chat`, `/v1/rag`, or `/v1/documents/{id}/ask`.
    *
    * @param {InferenceClient.RequestOptions} requestOptions - Request-specific configuration.
    *
@@ -9505,7 +10116,7 @@ var InferenceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/models");
   }
   /**
-   * Streams a model response as Server-Sent Events (SSE). Send the full conversation history in the `messages` array; a message with role `system` is extracted and used as the system prompt. On a pre-paid account, token cost is debited from your inference balance; usage-billed accounts accrue it for post-billing. A request routed through your own `providerAlias` incurs no Vectros token cost. A small per-call flat fee is charged to your monthly credit allowance, except when the call fails on the server side. Requires the `inference:r` scope.
+   * Streams a model response as Server-Sent Events (SSE). Send the full conversation history in the `messages` array; a message with role `system` is extracted and used as the system prompt. On a pre-paid account, token cost is debited from your inference balance; usage-billed accounts accrue it for post-billing. A request routed through your own `providerAlias` incurs no Vectros token cost. A per-call platform fee is charged to your monthly credit allowance, except when the call fails on the server side: 0.2 credits for a call of up to 60 seconds, then 1 credit per 5 minutes of the call's duration. Requires the `inference:r` scope.
    */
   chatInference(request, requestOptions) {
     return HttpResponsePromise.fromPromise(this.__chatInference(request, requestOptions));
@@ -9577,7 +10188,7 @@ var InferenceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/chat");
   }
   /**
-   * Loads a single document's extracted text, supplies it as context, and streams a model answer about it. The document must be fully indexed. If the document exceeds the 32K-token cap, the call returns 413 with no credits charged — use `POST /v1/rag` instead to answer over larger or multi-document collections. Requires the `inference:r` scope.
+   * Loads a single document's extracted text, supplies it as context, and streams a model answer about it. The document must have finished processing and have text. If the document exceeds the 32K-token cap, the call returns 413 with no credits charged — use `POST /v1/rag` instead to answer over larger or multi-document collections. Requires the `inference:r` scope.
    */
   documentAsk(request, requestOptions) {
     return HttpResponsePromise.fromPromise(this.__documentAsk(request, requestOptions));
@@ -10712,8 +11323,7 @@ var SchemasClient = class {
    *                 }],
    *             capabilities: {
    *                 "auditHistory": true
-   *             },
-   *             allowedSurfaces: ["record"]
+   *             }
    *         }
    *     })
    */
@@ -10843,11 +11453,7 @@ var SchemasClient = class {
    * @example
    *     await client.schemas.updateSchema({
    *         id: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
-   *         body: {
-   *             typeName: "intake_form",
-   *             displayName: "Client Intake Form",
-   *             allowedSurfaces: ["record"]
-   *         }
+   *         body: {}
    *     })
    */
   updateSchema(request, requestOptions) {
@@ -11387,7 +11993,7 @@ var ScriptsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/scripts/{id}");
   }
   /**
-   * Permanently deletes one script version by ID. Deleting one version does not affect any other version of the same name. Requires the `scripts:d` scope. Refused with 409 if a live trigger rule still references this version — either directly (a pinned `scriptRef`), or via `"latest"` when this IS the newest version of its name. Delete or re-point those rules first.
+   * Permanently deletes one script version by ID. Deleting one version does not affect any other version of the same name. Requires the `scripts:d` scope. Refused with 409 if a live trigger rule still references this version — either directly (a pinned `scriptRef`), or via `"latest"` when this IS the newest version of its name. Delete or re-point those rules first. Also refused with a retryable 409, deleting nothing, when it cannot be told yet whether this is the newest version (for example just after several of this name's newest versions were deleted, or while its first version is gone and the listing has not caught up) and a `"latest"` rule depends on the script: try again shortly.
    *
    * @param {Vectros.DeleteScriptRequest} request
    * @param {ScriptsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -11651,17 +12257,7 @@ var TriggersClient = class {
    *
    * @example
    *     await client.triggers.createTrigger({
-   *         body: {
-   *             name: "on-intake-create",
-   *             firingSource: {
-   *                 schemaId: "sch_9f8e7d6c",
-   *                 event: "CREATE"
-   *             },
-   *             scriptRef: {
-   *                 name: "notify-assignee",
-   *                 version: "3"
-   *             }
-   *         }
+   *         body: {}
    *     })
    */
   createTrigger(request, requestOptions) {
@@ -11790,17 +12386,7 @@ var TriggersClient = class {
    * @example
    *     await client.triggers.updateTrigger({
    *         id: "id",
-   *         body: {
-   *             name: "on-intake-create",
-   *             firingSource: {
-   *                 schemaId: "sch_9f8e7d6c",
-   *                 event: "CREATE"
-   *             },
-   *             scriptRef: {
-   *                 name: "notify-assignee",
-   *                 version: "3"
-   *             }
-   *         }
+   *         body: {}
    *     })
    */
   updateTrigger(request, requestOptions) {
@@ -11925,6 +12511,9 @@ var VectrosClient = class {
   get auth() {
     return this._auth ?? (this._auth = new AuthClient(this._options));
   }
+  get agents() {
+    return this._agents ?? (this._agents = new AgentsClient(this._options));
+  }
   get documents() {
     return this._documents ?? (this._documents = new DocumentsClient(this._options));
   }
@@ -11992,7 +12581,11 @@ var logging;
 var import_zod = require("zod");
 var import_zod2 = require("zod");
 var CONTEXT_ID_RE = /^[a-z][a-z0-9-]{2,30}$/;
-var FORGERY_CHARS_RE = /[\x00-\x1f\x7f-\x9f\u00ad\u061c\u200b-\u200f\u2028\u2029\u202a-\u202e\u2060\u2066-\u2069\ufeff\u{e0000}-\u{e007f}]/u;
+var FORGERY_CHARS_RE = (
+  // eslint-disable-next-line no-control-regex -- matching control characters is what this pattern is for
+  /[\x00-\x1f\x7f-\x9f\u00ad\u061c\u115f\u1160\u180e\u200b-\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u206f\u3164\ufeff\uffa0\ufff9-\ufffb\u{1bca0}-\u{1bca3}\u{1d173}-\u{1d17a}\u{e0000}-\u{e007f}]/u
+);
+var FORGERY_CHARS_GLOBAL_RE = new RegExp(FORGERY_CHARS_RE.source, "gu");
 function safeDisplayString(base) {
   return base.refine((v) => !FORGERY_CHARS_RE.test(v), {
     message: "must not contain control characters, invisible/zero-width characters, line/paragraph separators, or bidi marks/overrides \u2014 these can forge, hide, or reorder text in a rendered plan preview"
@@ -12159,7 +12752,8 @@ var BlueprintLookupFieldSchema = import_zod.z.union([
     // or a declared field on this schema. Locked at create. Valid on a
     // composite lookup too — it orders WITHIN a group when a query supplies
     // fewer values than the lookup declares, not across the whole result.
-    sortBy: import_zod.z.string().min(1).optional(),
+    // Printed by the CLI's lint findings, so held to the displayed-text rule like the other names here.
+    sortBy: safeDisplayString(import_zod.z.string().min(1)).optional(),
     // Opt a field past the fixed fast-index budget into a higher-cost
     // secondary index. No effect on a field that fits within the budget.
     allowOverflow: import_zod.z.boolean().optional()
@@ -12376,7 +12970,7 @@ var BlueprintAccessProfileSchema = import_zod.z.object({
   // this file, and so a future preview enhancement that starts showing these values (a very
   // plausible one, given the existing renderPlanDataScope precedent) doesn't silently reopen
   // this exact class on a field that looks, byte-for-byte, like every other one already closed.
-  dataScope: import_zod.z.record(import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()]))).optional(),
+  dataScope: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()]))).optional(),
   // Optional identity overrides for the service principal's profile — scope
   // values its key STAMPS onto everything it writes (a credential can only
   // stamp ownership its identity carries). Keys are the namespaced `scope:<ns>`
@@ -12389,7 +12983,7 @@ var BlueprintAccessProfileSchema = import_zod.z.object({
   // below (`lintIdentityOverrides`, placeholder-aware — see that function's
   // docstring); this `.min(1)` is only the shape-level "non-blank" guard on
   // the value, not the grammar check.
-  identityOverrides: import_zod.z.record(import_zod.z.string().min(1)).optional(),
+  identityOverrides: import_zod.z.record(import_zod.z.string(), import_zod.z.string().min(1)).optional(),
   // Optional capabilities granted to the blueprint's own service-principal
   // profile. DECISION: allowed here, not role-clause-only. On the platform,
   // an access profile's scopes are themselves a list of clauses — the exact
@@ -12453,7 +13047,7 @@ var BlueprintAccessProfileSchema = import_zod.z.object({
 });
 var BlueprintRoleClauseSchema = import_zod.z.object({
   allowedActions: import_zod.z.array(safeDisplayString(import_zod.z.string().min(1))).min(1),
-  dataScope: import_zod.z.record(import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()]))).optional(),
+  dataScope: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()]))).optional(),
   dataScopeRef: import_zod.z.string().min(1).optional(),
   capabilities: GrantedCapabilitiesSchema,
   assignableRoles: AssignableRolesSchema
@@ -12467,11 +13061,12 @@ var BlueprintRoleClauseSchema = import_zod.z.object({
   }
 });
 var BlueprintFragmentsSchema = import_zod.z.record(
-  import_zod.z.record(import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()])))
+  import_zod.z.string(),
+  import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()])))
 );
 var BlueprintRolesSchema = import_zod.z.record(safeDisplayString(import_zod.z.string().min(1)), import_zod.z.array(BlueprintRoleClauseSchema).min(1));
-var BlueprintRoleAssumableSchema = import_zod.z.record(import_zod.z.array(safeDisplayString(import_zod.z.string().min(1))).min(1));
-var BlueprintRoleAssumableMapSchema = import_zod.z.record(BlueprintRoleAssumableSchema);
+var BlueprintRoleAssumableSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.array(safeDisplayString(import_zod.z.string().min(1))).min(1));
+var BlueprintRoleAssumableMapSchema = import_zod.z.record(import_zod.z.string(), BlueprintRoleAssumableSchema);
 var BlueprintTriggerFiringSourceSchema = import_zod.z.object({
   schemaName: import_zod.z.string().min(1),
   event: import_zod.z.enum(["CREATE", "UPDATE", "DELETE"])
@@ -12505,7 +13100,7 @@ var BlueprintTriggerEntrySchema = import_zod.z.object({
   scriptRef: BlueprintTriggerScriptRefSchema,
   allowedActions: import_zod.z.array(safeDisplayString(import_zod.z.string().min(1))).min(1).optional(),
   roleIds: import_zod.z.array(import_zod.z.string().min(1)).min(1).optional(),
-  dataScope: import_zod.z.record(import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()]))).optional(),
+  dataScope: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.union([safeDisplayString(import_zod.z.string().min(1)), import_zod.z.null()]))).optional(),
   capabilities: GrantedCapabilitiesSchema,
   manifest: BlueprintTriggerManifestSchema,
   /**
@@ -12585,7 +13180,113 @@ var BlueprintScriptEntrySchema = import_zod.z.object({
     message: `'declaredInputContract' exceeds the platform's ${SCRIPT_INPUT_CONTRACT_MAX_BYTES.toLocaleString("en-US")}-byte cap (measured in UTF-8 bytes, not characters)`
   }).optional()
 }).strict();
-var BlueprintScriptsSchema = import_zod.z.record(BlueprintScriptEntrySchema);
+var BlueprintScriptsSchema = import_zod.z.record(import_zod.z.string(), BlueprintScriptEntrySchema);
+var BLUEPRINT_FORMAT_VERSION = 2;
+var AGENT_LIMITS = {
+  descriptionChars: 500,
+  modelChars: 100,
+  systemChars: 32e3,
+  tools: 50,
+  maxSteps: 25,
+  minTokensPerCall: 16,
+  maxTokensPerCall: 8192,
+  maxToolCalls: 50,
+  maxWrites: 1e3,
+  maxInferenceCents: 500
+};
+var AGENT_TOOL_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+var BlueprintAgentToolSchema = import_zod.z.object({
+  /** The tool's name in the platform's tool catalog. Checked against the catalog when the blueprint is applied. */
+  name: import_zod.z.string().regex(AGENT_TOOL_NAME_RE, {
+    message: "a tool name is 1-64 characters of letters, digits, underscores ('_') and hyphens ('-')"
+  }),
+  /** Required `true` for a tool that creates, changes or deletes data. */
+  allowWrites: import_zod.z.boolean().optional()
+}).strict();
+var BlueprintAgentEntrySchema = import_zod.z.object({
+  description: import_zod.z.string().max(AGENT_LIMITS.descriptionChars).optional(),
+  /**
+   * Whose identity the agent's tool calls run with. `CALLER` (the caller who starts the run) is the only value the platform accepts
+   * today. Checked here for its SHAPE only, never against a list: the set will grow, and the platform refuses a value it does not
+   * support when the blueprint is applied, so an older copy of this package never refuses a value a newer platform accepts.
+   */
+  authority: import_zod.z.string().regex(/^[A-Z][A-Z_]{0,31}$/, { message: "authority is an upper-case name such as 'CALLER'" }).optional(),
+  /** The model the agent runs on, by its id in the model catalog. */
+  // Shown in the plan preview, so held to the same rule as every other displayed text.
+  model: safeDisplayString(import_zod.z.string().min(1).max(AGENT_LIMITS.modelChars)),
+  /** The system prompt. */
+  system: import_zod.z.string().max(AGENT_LIMITS.systemChars).optional(),
+  /** The tool whitelist. */
+  tools: import_zod.z.array(BlueprintAgentToolSchema).max(AGENT_LIMITS.tools).optional(),
+  limits: import_zod.z.object({
+    maxSteps: import_zod.z.number().int().min(1).max(AGENT_LIMITS.maxSteps).optional(),
+    maxTokensPerCall: import_zod.z.number().int().min(AGENT_LIMITS.minTokensPerCall).max(AGENT_LIMITS.maxTokensPerCall).optional(),
+    maxToolCalls: import_zod.z.number().int().min(0).max(AGENT_LIMITS.maxToolCalls).optional(),
+    maxWrites: import_zod.z.number().int().min(0).max(AGENT_LIMITS.maxWrites).optional()
+  }).strict().optional(),
+  budget: import_zod.z.object({
+    /** US cents per run, up to 500. The platform also enforces a minimum and refuses a lower value when the blueprint is applied. */
+    maxInferenceCents: import_zod.z.number().int().min(1).max(AGENT_LIMITS.maxInferenceCents).optional()
+  }).strict().optional()
+}).strict();
+var BlueprintAgentsSchema = import_zod.z.record(safeDisplayString(import_zod.z.string()), BlueprintAgentEntrySchema);
+function assertSupportedFormatVersion(input) {
+  if (input === null || typeof input !== "object") return;
+  const declared = input.formatVersion;
+  if (typeof declared === "number" && Number.isInteger(declared) && declared > BLUEPRINT_FORMAT_VERSION) {
+    throw new BlueprintValidationError(
+      `This blueprint uses format version ${declared}; this tool supports format versions up to ${BLUEPRINT_FORMAT_VERSION}. Upgrade @vectros-ai/cli and @vectros-ai/blueprints and try again.`,
+      [{ path: "formatVersion", message: `unsupported format version ${declared}` }]
+    );
+  }
+}
+function lintAgents(value, ctx) {
+  const bp = value;
+  const agents = bp.agents;
+  if (!agents) return;
+  if ((bp.formatVersion ?? 1) < 2) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["formatVersion"],
+      message: "an 'agents' section needs 'formatVersion: 2' (so a tool that reads an older format refuses the file instead of misreading it)"
+    });
+  }
+  for (const [name, agent] of Object.entries(agents)) {
+    if (!SCRIPT_NAME_RE.test(name)) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        path: ["agents", name],
+        message: `agents['${displaySafe(name, 80)}'] is not a valid agent name \u2014 use 1-64 characters of letters, digits, underscores ('_') and hyphens ('-'). The map key IS the name the platform stores.`
+      });
+    }
+    const tools = agent?.tools ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    tools.forEach((tool, i) => {
+      if (seen.has(tool.name)) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          path: ["agents", name, "tools", i, "name"],
+          message: `tool '${displaySafe(tool.name, 80)}' is listed twice`
+        });
+      }
+      seen.add(tool.name);
+    });
+    if (tools.some((t) => t.allowWrites === true) && (agent?.limits?.maxWrites ?? 0) < 1) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        path: ["agents", name, "limits", "maxWrites"],
+        message: "limits.maxWrites must be at least 1 when a tool has allowWrites: true"
+      });
+    }
+    if (tools.length > 0 && agent?.limits?.maxToolCalls === 0) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        path: ["agents", name, "limits", "maxToolCalls"],
+        message: "limits.maxToolCalls must be at least 1 when tools are listed"
+      });
+    }
+  }
+}
 var IDENTITY_NAMESPACE_RE = /^[a-z][a-z0-9_-]{1,31}$/;
 var FORBIDDEN_IDENTITY_NAMESPACES = /* @__PURE__ */ new Set(["record", "document", "entity", "user"]);
 var IdentityKindSchema = import_zod.z.string().min(1).superRefine((val, ctx) => {
@@ -12613,7 +13314,7 @@ var IdentityDeclSchema = import_zod.z.object({
   // sibling fields) — it does reach a platform API payload as an entity's `name`.
   externalId: safeDisplayString(import_zod.z.string().min(1)),
   displayName: safeDisplayString(import_zod.z.string().min(1)).optional(),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 }).strict();
 var IDENTITY_NAME_RE = /^[A-Za-z_]\w*$/;
 var IdentitiesDeclSchema = import_zod.z.record(
@@ -12759,8 +13460,7 @@ var BlueprintIssuerSchema = import_zod.z.object({
    */
   capturedClaims: import_zod.z.array(
     // `safeDisplayString` (a `.refine`) then the blank-name `.refine` — both ordered AFTER
-    // `.max`, since `.refine` returns a ZodEffects, which has no `.max` (`.refine` itself
-    // chains fine onto a ZodEffects — it's on the ZodType base, not ZodString-specific).
+    // `.max`, by the same last-call convention.
     // `.min(1)` would be a LENGTH check and would admit a whitespace-only name while the
     // message claims "non-blank"; the platform rejects on isBlank(). Note the value is
     // REJECTED, not trimmed — it reaches the wire exactly as authored, matching how the
@@ -12973,7 +13673,7 @@ var RecordSeedSchema = import_zod.z.object({
   surface: import_zod.z.literal("record"),
   ...SeedCommonShape,
   /** The record payload, validated against the bound schema. */
-  fields: import_zod.z.record(import_zod.z.unknown())
+  fields: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
 }).strict();
 var DocumentSeedSchema = import_zod.z.object({
   surface: import_zod.z.literal("document"),
@@ -12983,7 +13683,7 @@ var DocumentSeedSchema = import_zod.z.object({
   /** Raw text content to ingest + index — REQUIRED and non-empty (the platform rejects a blank ingest). */
   text: import_zod.z.string().min(1),
   /** Optional structured payload bound to the schema (the document's `fields`). */
-  fields: import_zod.z.record(import_zod.z.unknown()).optional()
+  fields: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 }).strict();
 var BlueprintSeedRecordSchema = import_zod.z.discriminatedUnion("surface", [
   RecordSeedSchema,
@@ -13608,6 +14308,8 @@ var BLUEPRINT_FIELD_PHASES = Object.freeze({
   // principal/AccessProfile pairs instead of one), so it applies in the identical in-context phase,
   // under the same re-minted context-confined token.
   triggers: "in-context",
+  // Written with the same in-context, context-confined token as scripts and triggers.
+  agents: "in-context",
   // Setting it requires the platform provisioning capability, which only the bootstrap credential
   // carries — the same reasoning as issuers/namespaces above. It is applied to the app context
   // itself, which the bootstrap phase already creates, so there is nothing for the in-context pass
@@ -13734,7 +14436,7 @@ var BlueprintSchema = import_zod.z.object({
     // safeDisplayString: rendered raw into buildPlan's context step (`identity projection:
     // [...]`) — same rendered-plan-preview shape as `capturedClaims` (its structural pair);
     // the same ordering rule applies (safeDisplayString's own `.refine` before the blank-name `.refine` below,
-    // both after `.max` since `.refine` returns a ZodEffects with no `.max`).
+    // both after `.max`, by the last-call convention).
     safeDisplayString(
       import_zod.z.string().max(MAX_CAPTURED_CLAIM_NAME_LENGTH, {
         message: `an identityProjectionClaims entry must be at most ${MAX_CAPTURED_CLAIM_NAME_LENGTH} characters`
@@ -13765,7 +14467,16 @@ var BlueprintSchema = import_zod.z.object({
    * composes) are live authority, not a declaration awaiting a future release. Author the grant as
    * narrowly as you would any other credential's.
    */
-  triggers: BlueprintTriggersSchema.optional()
+  triggers: BlueprintTriggersSchema.optional(),
+  /**
+   * The blueprint format version; absent means 1. A blueprint with an `agents` section declares 2.
+   */
+  formatVersion: import_zod.z.number().int().min(1).max(BLUEPRINT_FORMAT_VERSION).optional(),
+  /**
+   * Optional stored agents: agentName -> definition. A run of an agent calls tools with the identity
+   * and permissions of the caller who starts the run, further limited by the agent's tool whitelist.
+   */
+  agents: BlueprintAgentsSchema.optional()
 }).strict().superRefine((bp, ctx) => {
   lintSelfTokenPlacement(bp, ctx);
   lintIdentityRefs(bp, ctx);
@@ -13784,17 +14495,46 @@ var BlueprintSchema = import_zod.z.object({
   lintTriggers(bp, ctx);
   lintTriggerFields(bp, ctx);
   lintScripts(bp, ctx);
+  lintAgents(bp, ctx);
 });
+function displaySafe(text, maxLength = Number.POSITIVE_INFINITY) {
+  const shown = Array.from(text.replace(FORGERY_CHARS_GLOBAL_RE, "?"));
+  return shown.length > maxLength ? `${shown.slice(0, maxLength).join("")}...` : shown.join("");
+}
+function displaySafeInline(text, maxLength = Number.POSITIVE_INFINITY) {
+  return displaySafe(text.replace(/\r\n|[\r\n\u0085\u2028\u2029]/g, " "), maxLength);
+}
+function displaySafeLines(text) {
+  return text.replace(/\r\n/g, "\n").split("\n").map((line) => displaySafe(line)).join("\n");
+}
+function neutralizeIssues(issues) {
+  return issues.map((i) => ({ path: displaySafe(i.path), message: displaySafe(i.message) }));
+}
+function quotedKeysSafe(issue) {
+  return displaySafe(issue.message, issue.code === "unrecognized_keys" ? 300 : Number.POSITIVE_INFINITY);
+}
 function formatIssuePath(path4) {
   let out = "";
   for (const seg of path4) {
     if (typeof seg === "number") out += `[${seg}]`;
-    else out += out.length ? `.${seg}` : seg;
+    else out += out.length ? `.${displaySafe(String(seg))}` : displaySafe(String(seg));
   }
   return out.length ? out : "(root)";
 }
+function flattenZodIssues(error) {
+  const out = [];
+  for (const i of error.issues) {
+    const nested = i.code === "invalid_key" ? i.issues : void 0;
+    if (nested && nested.length > 0) {
+      for (const n of nested) out.push({ path: [...i.path, ...n.path], message: quotedKeysSafe(n) });
+    } else {
+      out.push({ path: [...i.path], message: quotedKeysSafe(i) });
+    }
+  }
+  return out;
+}
 function toBlueprintIssues(error) {
-  return error.issues.map((i) => ({ path: formatIssuePath(i.path), message: i.message }));
+  return flattenZodIssues(error).map((i) => ({ path: formatIssuePath(i.path), message: i.message }));
 }
 function renderIssues(issues) {
   return issues.map((i) => `  \u2022 ${i.path}: ${i.message}`).join("\n");
@@ -13807,12 +14547,13 @@ var BlueprintValidationError = class extends Error {
    */
   issues;
   constructor(message, issues = []) {
-    super(message);
+    super(displaySafeLines(message));
     this.name = "BlueprintValidationError";
-    this.issues = issues;
+    this.issues = neutralizeIssues(issues);
   }
 };
 function parseBlueprint(input) {
+  assertSupportedFormatVersion(input);
   const result = BlueprintSchema.safeParse(input);
   if (!result.success) {
     const issues = toBlueprintIssues(result.error);
@@ -13828,9 +14569,9 @@ var IDENTITY_TOKEN_RE = /\$\{\{\s*identities\.([A-Za-z_]\w*)\s*\}\}/g;
 var BlueprintIdentityError = class extends Error {
   issues;
   constructor(message, issues = []) {
-    super(message);
+    super(displaySafeLines(message));
     this.name = "BlueprintIdentityError";
-    this.issues = issues;
+    this.issues = neutralizeIssues(issues);
   }
 };
 function collectIdentityReferences(value) {
@@ -13868,8 +14609,8 @@ async function resolveBlueprintIdentities(raw, resolve) {
   if (!parsed.success) {
     throw new BlueprintIdentityError(
       "Blueprint identities block is invalid",
-      parsed.error.issues.map((i) => ({
-        path: i.path.length ? `identities.${i.path.join(".")}` : "identities",
+      flattenZodIssues(parsed.error).map((i) => ({
+        path: i.path.length ? `identities.${i.path.map(String).join(".")}` : "identities",
         message: i.message
       }))
     );
@@ -13878,7 +14619,7 @@ async function resolveBlueprintIdentities(raw, resolve) {
   const undeclared = refs.filter((name) => !(name in declared));
   if (undeclared.length) {
     throw new BlueprintIdentityError(
-      `Blueprint references undeclared identities: ${undeclared.join(", ")}`,
+      `Blueprint references undeclared identities: ${undeclared.map((n) => displaySafe(n, 80)).join(", ")}`,
       undeclared.map((name) => ({
         path: `identities.${name}`,
         message: `'\${{ identities.${name} }}' is referenced but not declared in the 'identities' block`
@@ -13895,8 +14636,11 @@ async function resolveBlueprintIdentities(raw, resolve) {
       idMap[name] = id;
     } catch (err) {
       throw new BlueprintIdentityError(
-        `Failed to resolve identity '${name}' (${decl.kind} externalId=${decl.externalId}): ${err instanceof Error ? err.message : String(err)}`,
-        [{ path: `identities.${name}`, message: err instanceof Error ? err.message : String(err) }]
+        `Failed to resolve identity '${displaySafe(name, 80)}' (${decl.kind} externalId=${displaySafe(decl.externalId, 80)}): ${displaySafeInline(
+          err instanceof Error ? err.message : String(err),
+          500
+        )}`,
+        [{ path: `identities.${name}`, message: displaySafeInline(err instanceof Error ? err.message : String(err), 500) }]
       );
     }
   }
@@ -13909,13 +14653,13 @@ var InputDeclSchema = import_zod2.z.object({
   default: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()]).optional(),
   description: import_zod2.z.string().optional()
 }).strict();
-var InputsDeclSchema = import_zod2.z.record(InputDeclSchema);
+var InputsDeclSchema = import_zod2.z.record(import_zod2.z.string(), InputDeclSchema);
 var BlueprintInputError = class extends Error {
   issues;
   constructor(message, issues = []) {
-    super(message);
+    super(displaySafeLines(message));
     this.name = "BlueprintInputError";
-    this.issues = issues;
+    this.issues = neutralizeIssues(issues);
   }
 };
 function renderIssues2(issues) {
@@ -14107,7 +14851,7 @@ function resolveBlueprintInputs(raw, supplied = {}) {
     const parsed = InputsDeclSchema.safeParse(rawInputs);
     if (!parsed.success) {
       for (const i of parsed.error.issues) {
-        const p = i.path.length ? `inputs.${i.path.join(".")}` : "inputs";
+        const p = i.path.length ? `inputs.${i.path.map(String).join(".")}` : "inputs";
         issues.push({ path: p, message: i.message });
       }
     } else {
@@ -14144,8 +14888,9 @@ function resolveBlueprintInputs(raw, supplied = {}) {
   const ctx = { declared, values, builtins, issues };
   const substituted = substituteValue(body, ctx, "");
   if (issues.length) {
+    const clean = neutralizeIssues(issues);
     throw new BlueprintInputError(`Blueprint variable resolution failed:
-${renderIssues2(issues)}`, issues);
+${renderIssues2(clean)}`, clean);
   }
   return substituted;
 }
@@ -15750,6 +16495,48 @@ function createLogger2(ctx = {}) {
   );
 }
 
+// src/terminal-text.ts
+var STRIPPED = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu;
+function stripControlCharacters(value, maxLength = 200) {
+  const characters = Array.from(value.replace(STRIPPED, ""));
+  return characters.length > maxLength ? `${characters.slice(0, maxLength).join("")}...` : characters.join("");
+}
+function singleLine(value, maxLength = 200) {
+  return stripControlCharacters(value.replace(/\r\n|[\r\n\u0085\u2028\u2029\t\v\f]/g, " "), maxLength);
+}
+function cleanBlock(value, maxLineLength = 2e3, limits = {}) {
+  const maxLines = limits.maxLines ?? 200;
+  const maxChars = limits.maxChars ?? 2e4;
+  const lines = value.split(/\r\n|[\r\n\u0085\u2028\u2029]/);
+  let cut = lines.length > maxLines;
+  let text = lines.slice(0, maxLines).map((line) => stripControlCharacters(line.replace(/\t/g, " "), maxLineLength)).join("\n");
+  if (text.length > maxChars) {
+    text = text.slice(0, maxChars);
+    cut = true;
+  }
+  return cut ? `${text}
+[truncated]` : text;
+}
+function shortPath(value, maxLength = 300) {
+  const clean = Array.from(singleLine(value, Number.MAX_SAFE_INTEGER));
+  if (clean.length <= maxLength) return clean.join("");
+  const head = Math.floor((maxLength - 3) / 3);
+  return `${clean.slice(0, head).join("")}...${clean.slice(clean.length - (maxLength - 3 - head)).join("")}`;
+}
+function errorText(err) {
+  return cleanBlock(err instanceof Error ? err.message : String(err));
+}
+function quotedBlock(value, indent = "    ") {
+  return cleanBlock(value).split("\n").map((line, i) => i === 0 || line === "" ? line : `${indent}${line}`).join("\n");
+}
+function asText(value, fallback = "(unprintable)") {
+  try {
+    return String(value);
+  } catch {
+    return fallback;
+  }
+}
+
 // src/output.ts
 function formatJson(value) {
   return JSON.stringify(value, null, 2);
@@ -15791,19 +16578,19 @@ function extractServerError(err) {
     if (e.body && typeof e.body === "object") {
       const b = e.body;
       if (typeof b.message === "string" && b.message.trim()) serverMessage = b.message.trim();
-      if (typeof b.requestId === "string" && b.requestId.trim()) requestId = b.requestId.trim();
-      if (typeof b.errorCode === "string" && b.errorCode.trim()) errorCode = b.errorCode.trim();
+      if (typeof b.requestId === "string" && b.requestId.trim()) requestId = singleLine(b.requestId.trim(), 100);
+      if (typeof b.errorCode === "string" && b.errorCode.trim()) errorCode = singleLine(b.errorCode.trim(), 100);
     } else if (typeof e.body === "string" && e.body.trim()) {
       serverMessage = e.body.trim();
     }
-    if (serverMessage) return { statusCode, message: serverMessage, requestId, errorCode };
+    if (serverMessage) return { statusCode, message: cleanBlock(serverMessage), requestId, errorCode };
     const message = typeof e.message === "string" ? e.message : "";
     const isSdkEnvelope = /\nStatus code:/.test(message);
-    if (message && !isSdkEnvelope) return { statusCode, message, requestId, errorCode };
+    if (message && !isSdkEnvelope) return { statusCode, message: cleanBlock(message), requestId, errorCode };
     if (statusCode) return { statusCode, message: `HTTP ${statusCode}`, requestId, errorCode };
-    if (message) return { statusCode, message, requestId, errorCode };
+    if (message) return { statusCode, message: cleanBlock(message), requestId, errorCode };
   }
-  return { message: String(err) };
+  return { message: cleanBlock(String(err)) };
 }
 function formatError(err) {
   return extractServerError(err).message;
@@ -16021,6 +16808,33 @@ var PROVISION_OPTIONS = [
       ]
     }
   },
+  {
+    flag: "--allow-agent-adoption",
+    stacked: true,
+    modes: ["bootstrap", "apply"],
+    help: {
+      bootstrap: [
+        "Required to write a blueprint's agent over an agent that already exists",
+        "in this context but carries no blueprint mark (made by hand, or by a tool",
+        "that set none) \u2014 without it, bootstrap refuses for that name, naming it,",
+        "and writes nothing to the agent. Adopting marks the agent as this",
+        "blueprint's and writes the declared definition as its next version if it",
+        "differs, so every run using its latest version changes. Never needed for a",
+        "brand-new agent, or one this blueprint already manages. Does NOT help if",
+        "the agent is managed by a DIFFERENT blueprint \u2014 that is always refused."
+      ],
+      apply: [
+        "Required to write a blueprint's agent over an agent that already exists",
+        "in this context but carries no blueprint mark (made by hand, or by a tool",
+        "that set none) \u2014 without it, apply refuses for that name, naming it,",
+        "and writes nothing to the agent. Adopting marks the agent as this",
+        "blueprint's and writes the declared definition as its next version if it",
+        "differs, so every run using its latest version changes. Never needed for a",
+        "brand-new agent, or one this blueprint already manages. Does NOT help if",
+        "the agent is managed by a DIFFERENT blueprint \u2014 that is always refused."
+      ]
+    }
+  },
   {
     flag: "--tenant",
     value: "test|live",
@@ -16162,16 +16976,24 @@ var PROVISION_OPTIONS = [
         "\u2014 e.g. a deliberate second machine for an integration you already own.",
         "Refused by default so an unexpected collision halts a CI run loudly",
         "instead of silently minting a credential bound to the wrong identity.",
-        "Never needed for --rotate or an ordinary same-machine re-apply."
+        "Not needed for --rotate or an ordinary same-machine re-apply of the",
+        "blueprint's own service principal (a trigger principal is the exception, below).",
+        "Also required the same way when a trigger's service principal already exists",
+        "and this blueprint did not mark it (made by an earlier release, or by hand).",
+        "The first confirmation marks it as this blueprint's (needs users:u); then it is not asked again."
       ],
       apply: [
         "Required (with --yes, or with no TTY) when the blueprint's service principal",
         "already exists in your tenant. Apply never reads a local key record, so that is",
         "every apply once the principal exists, on any machine, including one that ran",
-        "bootstrap. It lets apply rewrite that principal's access profile (the",
-        "blueprint's own service principal only). In a pipeline this flag is STANDING",
-        "consent: it also waves through a blueprint whose servicePrincipal.externalId",
-        "collides with an unrelated identity, so keep the blueprint's source reviewed.",
+        "bootstrap. It lets apply rewrite that principal's access profile. It also",
+        "covers a trigger's service principal that already exists and that this",
+        "blueprint did not mark (made by an earlier release, or by hand): the first",
+        "confirmation marks it as this blueprint's (needs users:u; apply says if it",
+        "could not), and it is not asked again. In a",
+        "pipeline this flag is STANDING consent: it also waves through a blueprint whose",
+        "servicePrincipal.externalId or trigger name collides with an unrelated identity,",
+        "so keep the blueprint's source reviewed.",
         "Every run that proceeds prints which principal it reused and why."
       ]
     }
@@ -16487,13 +17309,6 @@ var import_promises = require("fs/promises");
 var import_node_os = require("os");
 var import_node_path = require("path");
 
-// src/terminal-text.ts
-var STRIPPED = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu;
-function stripControlCharacters(value, maxLength = 200) {
-  const characters = Array.from(value.replace(STRIPPED, ""));
-  return characters.length > maxLength ? `${characters.slice(0, maxLength).join("")}...` : characters.join("");
-}
-
 // src/pkce.ts
 var import_node_crypto = require("crypto");
 
@@ -16794,10 +17609,10 @@ function parseDocument(raw, filePath) {
   const ext = (0, import_node_path2.extname)(filePath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml") {
     try {
-      return (0, import_yaml.parse)(raw);
+      return (0, import_yaml.parse)(raw, { logLevel: "error" });
     } catch (err) {
       if (err instanceof import_yaml.YAMLParseError) {
-        throw new Error(`Blueprint YAML is invalid in '${filePath}': ${err.message}`);
+        throw new Error(`Blueprint YAML is invalid in '${shortPath(filePath, 300)}': ${quotedBlock(err.message)}`);
       }
       throw err;
     }
@@ -16806,7 +17621,7 @@ function parseDocument(raw, filePath) {
     return JSON.parse(raw);
   } catch (err) {
     throw new BlueprintValidationError(
-      `Blueprint is not valid JSON in '${filePath}': ${err instanceof Error ? err.message : String(err)}`
+      `Blueprint is not valid JSON in '${shortPath(filePath, 300)}': ${quotedBlock(err instanceof Error ? err.message : String(err))}`
     );
   }
 }
@@ -16816,7 +17631,7 @@ async function loadBlueprintFile(filePath, supplied = {}) {
     raw = await (0, import_promises2.readFile)(filePath, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`Cannot read blueprint file '${filePath}': ${msg}`);
+    throw new Error(`Cannot read blueprint file '${shortPath(filePath, 300)}': ${quotedBlock(msg)}`);
   }
   const parsed = parseDocument(raw, filePath);
   const resolved = resolveBlueprintInputs(parsed, supplied);
@@ -16838,11 +17653,11 @@ async function loadValuesFile(filePath) {
   try {
     raw = await (0, import_promises2.readFile)(filePath, "utf8");
   } catch (err) {
-    throw new Error(`Cannot read --values file '${filePath}': ${err instanceof Error ? err.message : String(err)}`);
+    throw new Error(`Cannot read --values file '${shortPath(filePath, 300)}': ${quotedBlock(err instanceof Error ? err.message : String(err))}`);
   }
   const parsed = parseDocument(raw, filePath);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`--values file '${filePath}' must be a map of name: value pairs.`);
+    throw new Error(`--values file '${shortPath(filePath, 300)}' must be a map of name: value pairs.`);
   }
   return parsed;
 }
@@ -16861,7 +17676,8 @@ var DATA_PLANE_ALLOWLIST = [
   "documents",
   "folders",
   "inference",
-  "entities"
+  "entities",
+  "runs"
 ];
 var KNOWN_CONTROL_PLANE_RESOURCES = [
   "keys",
@@ -16903,7 +17719,10 @@ var KNOWN_CONTROL_PLANE_RESOURCES = [
   // no admitted resource has an `x` verb — adding it would instead make `records:x` pass the op
   // check and be admitted as data-plane.
   "scripts",
-  "triggers"
+  "triggers",
+  // Stored agent definitions: authoring one steers every run of it, so the platform treats it as
+  // control-plane on every verb. Listed for MESSAGE QUALITY, as above.
+  "agents"
 ];
 var PARTIALLY_ADMITTED_OPS = /* @__PURE__ */ new Map([
   ["profiles", /* @__PURE__ */ new Set(["r", "u", "d"])]
@@ -17141,6 +17960,9 @@ function assertBlueprintGates(blueprint) {
     }
   }
   for (const [triggerName, entry] of Object.entries(blueprint.triggers ?? {})) {
+    const carried = entry.allowedActions ?? (entry.roleIds ?? []).flatMap((id) => (blueprint.roles?.[id] ?? []).flatMap((clause) => clause.allowedActions));
+    const refused = triggerRefusedGrants(carried);
+    if (refused.length > 0) throw withTriggerContext(new ScopeGateError(refused), triggerName);
     if (entry.allowedActions === void 0) continue;
     try {
       assertScopeGate(entry.allowedActions, entry.capabilities);
@@ -17179,6 +18001,20 @@ function assertScriptGrantsNameADeclaredScript(blueprint) {
   }
   if (rejected.length > 0) throw new ScopeGateError(rejected);
 }
+var TRIGGER_REFUSED_RESOURCES = /* @__PURE__ */ new Set(["runs"]);
+function triggerRefusedGrants(actions) {
+  const out = [];
+  for (const action of actions) {
+    const resource = action.trim().split(":")[0];
+    if (TRIGGER_REFUSED_RESOURCES.has(resource)) {
+      out.push({
+        action,
+        reason: `requests '${resource}' for a trigger. A trigger principal is unattended and fires on every matching write, so it may not be granted '${resource}'; grant it to a role or the blueprint's own credential instead`
+      });
+    }
+  }
+  return out;
+}
 function withTriggerContext(err, triggerName) {
   if (err instanceof ScopeGateError || err instanceof CapabilityGateError) {
     for (const r of err.rejected) r.source ??= `trigger '${triggerName}'`;
@@ -17476,6 +18312,45 @@ async function drainPages(fetch2) {
   return out;
 }
 
+// src/agent-api.ts
+var AGENT_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+var APPLY_AGENT_SCOPES = "'agents:c', plus 'agents:u' and 'agents:r' when the agent already exists (changed or not)";
+function agentErrorHint(err, contextId, scopes) {
+  const info = extractServerError(err);
+  if (info.statusCode === 403) {
+    return `This needs the ${scopes} scope on the credential, in context '${contextId}'. Grant it to the principal doing this, or use a credential that holds it.`;
+  }
+  if (info.statusCode === 400 && /already in use/i.test(info.message)) {
+    return "If the agent exists, this credential may be unable to read it: re-applying or writing over an existing agent needs 'agents:r' and 'agents:u' as well as 'agents:c'.";
+  }
+  if (info.errorCode === "AGENT_RETIRED" || info.statusCode === 409 && /\b(retired|purged)\b/i.test(info.message)) {
+    return "A retired agent keeps its name. Restore it with `vectros agents version <id> --restore --file <definition>` (a purged agent cannot be restored), or remove the agent from the blueprint.";
+  }
+  return "";
+}
+function agentRequestError(err, subject, contextId, scopes) {
+  const info = extractServerError(err);
+  const hint = agentErrorHint(err, contextId, scopes);
+  const message = singleLine(info.message, 500);
+  if (info.statusCode === 403) {
+    return new Error(`${subject}: the platform refused the request (403). ${hint} Platform message: ${message}`, { cause: err });
+  }
+  return new Error(`${subject}: ${message}${hint ? ` ${hint}` : ""}`, { cause: err });
+}
+function sanitizedAgentError(err) {
+  const info = extractServerError(err);
+  const message = singleLine(info.message, 500);
+  return Object.assign(new Error(message), {
+    statusCode: info.statusCode,
+    body: {
+      message,
+      requestId: info.requestId === void 0 ? void 0 : singleLine(info.requestId, 100),
+      errorCode: info.errorCode === void 0 ? void 0 : singleLine(info.errorCode, 100)
+    },
+    cause: err
+  });
+}
+
 // src/shell-quote.ts
 function shellQuote(value) {
   if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
@@ -17489,6 +18364,19 @@ function actionOf(created) {
 function triggerPrincipalExternalId(blueprintName, triggerName) {
   return `${blueprintName}-trigger-${triggerName}`;
 }
+function triggerPrincipalProvenance(payload, blueprintName) {
+  const marker = payload?.provisionedBy;
+  if (marker === blueprintName) return { kind: "ours" };
+  if (typeof marker === "string" && marker.length > 0) return { kind: "other-blueprint", markedBy: marker };
+  return { kind: "unmarked" };
+}
+var SENSITIVE_MASK = "[redacted]";
+function payloadIsMasked(value) {
+  if (value === SENSITIVE_MASK) return true;
+  if (Array.isArray(value)) return value.some(payloadIsMasked);
+  if (value !== null && typeof value === "object") return Object.values(value).some(payloadIsMasked);
+  return false;
+}
 var SCRIPT_CONFLICT_RETRY_DELAY_MS = 750;
 function isVersionConflict(err) {
   return typeof err === "object" && err !== null && err.statusCode === 409;
@@ -17542,7 +18430,7 @@ function scriptMatches(stored, declared) {
 var ScriptOwnershipConflictError = class extends Error {
   constructor(name, owner, blueprintName) {
     super(
-      `Script '${name}' is already provisioned by a different blueprint ('${owner}', this blueprint is '${blueprintName}') \u2014 refusing to push over it. No script version is pushed (anything already provisioned earlier in this same apply is unaffected). If you intended to replace that blueprint's script, do it under ITS name; if two blueprints legitimately need distinct code, give this one a different script name.`
+      `Script '${name}' is already provisioned by a different blueprint ('${singleLine(owner, 100)}', this blueprint is '${blueprintName}') \u2014 refusing to push over it. No script version is pushed (anything already provisioned earlier in this same apply is unaffected). If you intended to replace that blueprint's script, do it under ITS name; if two blueprints legitimately need distinct code, give this one a different script name.`
     );
     this.name = "ScriptOwnershipConflictError";
   }
@@ -17655,6 +18543,86 @@ async function ensureScripts(args) {
   }
   return actions;
 }
+var AgentAdoptionNotAllowedError = class extends Error {
+  constructor(agentName) {
+    super(
+      `Agent '${agentName}' already exists in this context and no blueprint manages it (it was made by hand, or by a tool that set no mark). Applying would mark it as this blueprint's and, if the declared definition differs, write that definition as its next version, so every run that uses the agent's latest version would start behaving differently. Nothing has been written to it, and its earlier versions stay readable. Re-run with --allow-agent-adoption once you have confirmed this blueprint should take over '${agentName}'. (Anything provisioned earlier in this same apply is unaffected.)`
+    );
+    this.agentName = agentName;
+    this.name = "AgentAdoptionNotAllowedError";
+  }
+  agentName;
+};
+var AgentOwnershipConflictError = class extends Error {
+  constructor(agentName, markedBy, blueprintName) {
+    super(
+      `Agent '${agentName}' is managed by the blueprint '${singleLine(markedBy, 100)}', not this one ('${blueprintName}'). Nothing has been written to it. An agent's mark cannot be changed, so give this blueprint's agent a different name, or apply the blueprint that manages it.`
+    );
+    this.agentName = agentName;
+    this.markedBy = markedBy;
+    this.name = "AgentOwnershipConflictError";
+  }
+  agentName;
+  markedBy;
+};
+function isDefiniteRefusal(err) {
+  const status = err?.statusCode;
+  return typeof status === "number" && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+async function ensureAgents(args) {
+  const { ctxClient, agents, blueprintName, contextId, allowAgentAdoption, onAgentCreated, onAgentSeen, onAgentAttempt, onAgentRefused, log } = args;
+  const actions = [];
+  const trackedByCaller = onAgentAttempt !== void 0;
+  const write = async (name, upsert) => {
+    try {
+      return await ctxClient.agents.createAgent(
+        {
+          contextId,
+          ...upsert ? { upsert: true } : {},
+          body: { ...agents[name], name, provisionedBy: blueprintName }
+        },
+        // The caller is keeping track of the agents it creates so that it can remove them. A create the client retried by
+        // itself after a gateway error would come back as an agent that already existed, hiding that this call made it.
+        trackedByCaller ? { maxRetries: 0 } : void 0
+      );
+    } catch (err) {
+      if (isDefiniteRefusal(err)) onAgentRefused?.(name);
+      throw agentRequestError(err, `Agent '${name}'`, contextId, APPLY_AGENT_SCOPES);
+    }
+  };
+  const versionOf = (name, answer) => {
+    const version = answer.version ?? answer.latestVersion;
+    if (!answer.id || version === void 0) {
+      throw new Error(`Agent '${name}': the platform's answer named no agent id or version.`);
+    }
+    return version;
+  };
+  for (const name of Object.keys(agents)) {
+    if (onAgentAttempt?.(name) === false) break;
+    const first = await write(name, false);
+    if (!first.created) onAgentSeen?.({ name, id: first.id });
+    const before = versionOf(name, first);
+    if (first.created) {
+      onAgentCreated?.({ name, id: first.id });
+      actions.push({ name, action: "created", id: first.id, version: before });
+      log.debug({ component: "loader", agentName: name, agentVersion: before }, "agent created at version 1");
+      continue;
+    }
+    const owner = first.provisionedBy?.trim() || void 0;
+    if (owner !== void 0 && owner !== blueprintName) throw new AgentOwnershipConflictError(name, owner, blueprintName);
+    const adopting = owner === void 0;
+    if (adopting && !allowAgentAdoption) throw new AgentAdoptionNotAllowedError(name);
+    const second = await write(name, true);
+    const after = versionOf(name, second);
+    const action = adopting ? "adopted" : after > before ? "versioned" : "unchanged";
+    actions.push({ name, action, id: first.id, version: after, previousVersion: before });
+    log.debug(
+      { component: "loader", agentName: name, agentVersionBefore: before, agentVersionAfter: after, action },
+      adopting ? "agent adopted into this blueprint" : action === "versioned" ? "agent definition changed \u2014 next version written" : "agent already current"
+    );
+  }
+  return actions;
+}
 async function pruneUndeclaredTriggers(args) {
   const { ctxClient, blueprintName, contextId, declaredNames, log } = args;
   const pruned = [];
@@ -17836,21 +18804,41 @@ var LostKeyError = class extends Error {
   }
   keyName;
 };
-var ExistingPrincipalNotConfirmedError = class extends Error {
-  constructor(contextId, userId, externalId, mintsKey = true) {
+var ExistingPrincipalNotConfirmedError = class extends Error {
+  constructor(contextId, userId, externalId, mintsKey = true) {
+    super(
+      mintsKey ? `About to bind a NEW scoped key to a principal that already existed in this tenant before this run (externalId '${externalId}', userId '${userId}', context '${contextId}'). This is either an intentional multi-machine setup for an integration you already own, or this blueprint's servicePrincipal.externalId collided with an unrelated existing identity \u2014 confirm before a new credential is minted bound to it.` : `About to write the grants of a principal that already existed in this tenant before this run (externalId '${externalId}', userId '${userId}', context '${contextId}'). This is either a re-apply of a blueprint you already manage, or this blueprint's servicePrincipal.externalId collided with an unrelated existing identity \u2014 confirm before that identity's access profile is changed.`
+    );
+    this.contextId = contextId;
+    this.userId = userId;
+    this.externalId = externalId;
+    this.mintsKey = mintsKey;
+    this.name = "ExistingPrincipalNotConfirmedError";
+  }
+  contextId;
+  userId;
+  externalId;
+  mintsKey;
+};
+var ExistingTriggerPrincipalNotConfirmedError = class extends Error {
+  constructor(contextId, triggerName, userId, externalId, provenance, markedBy) {
     super(
-      mintsKey ? `About to bind a NEW scoped key to a principal that already existed in this tenant before this run (externalId '${externalId}', userId '${userId}', context '${contextId}'). This is either an intentional multi-machine setup for an integration you already own, or this blueprint's servicePrincipal.externalId collided with an unrelated existing identity \u2014 confirm before a new credential is minted bound to it.` : `About to write the grants of a principal that already existed in this tenant before this run (externalId '${externalId}', userId '${userId}', context '${contextId}'). This is either a re-apply of a blueprint you already manage, or this blueprint's servicePrincipal.externalId collided with an unrelated existing identity \u2014 confirm before that identity's access profile is changed.`
+      `The service principal for trigger '${triggerName}' (externalId '${externalId}', userId '${userId}', context '${contextId}') already existed in this tenant and ` + (provenance === "other-blueprint" ? `is marked as provisioned by the blueprint '${singleLine(markedBy ?? "", 100)}', not this one. ` : `carries no provenance marker, so it was not created by this blueprint's trigger provisioning (it may be from an earlier CLI release, or created by hand). `) + `Applying would write that identity's access profile to this blueprint's trigger grant, and nothing has been written to it yet.`
     );
     this.contextId = contextId;
+    this.triggerName = triggerName;
     this.userId = userId;
     this.externalId = externalId;
-    this.mintsKey = mintsKey;
-    this.name = "ExistingPrincipalNotConfirmedError";
+    this.provenance = provenance;
+    this.markedBy = markedBy;
+    this.name = "ExistingTriggerPrincipalNotConfirmedError";
   }
   contextId;
+  triggerName;
   userId;
   externalId;
-  mintsKey;
+  provenance;
+  markedBy;
 };
 function mapEnumValues(enumValues) {
   if (!enumValues) return void 0;
@@ -17941,6 +18929,9 @@ var UnresolvedIdentitiesError = class extends Error {
     this.name = "UnresolvedIdentitiesError";
   }
 };
+function declaresAgents(blueprint) {
+  return Object.keys(blueprint.agents ?? {}).length > 0;
+}
 function assertNoUnresolvedIdentities(blueprint) {
   const hasBlock = blueprint.identities && Object.keys(blueprint.identities).length > 0;
   const refs = collectIdentityReferences(blueprint);
@@ -18075,6 +19066,11 @@ async function runLoader(client, input) {
     readExistingKey,
     persistMintedKey,
     allowScriptAdoption = false,
+    allowAgentAdoption = false,
+    onAgentCreated,
+    onAgentSeen,
+    onAgentAttempt,
+    onAgentRefused,
     log
   } = input;
   if (skipKey && rotate) {
@@ -18083,9 +19079,66 @@ async function runLoader(client, input) {
   assertNoUnresolvedIdentities(blueprint);
   const { contextAction, servicePrincipalUserId: userId, userAction, namespaceActions } = provisioned;
   assertBlueprintGates(blueprint);
+  const triggerPrincipalIds = /* @__PURE__ */ new Map();
+  const triggerPrincipalsToMark = /* @__PURE__ */ new Map();
+  const pendingConfirmation = [];
+  for (const triggerName of Object.keys(blueprint.triggers ?? {})) {
+    const externalId = triggerPrincipalExternalId(blueprint.name, triggerName);
+    const displayName = `Trigger: ${triggerName}`;
+    const triggerUser = await client.identity.createUser({
+      body: { externalId, type: "SERVICE", payload: { displayName, provisionedBy: blueprint.name } }
+    });
+    const triggerUserId = triggerUser.id;
+    if (!triggerUserId) {
+      throw new Error(`Trigger '${triggerName}' service-principal create returned no user id.`);
+    }
+    triggerPrincipalIds.set(triggerName, triggerUserId);
+    if (triggerUser.created) continue;
+    const provenance = triggerPrincipalProvenance(triggerUser.payload, blueprint.name);
+    if (provenance.kind === "ours") continue;
+    pendingConfirmation.push({
+      triggerName,
+      externalId,
+      userId: triggerUserId,
+      userType: triggerUser.type,
+      provenance: provenance.kind,
+      markedBy: provenance.kind === "other-blueprint" ? provenance.markedBy : void 0
+    });
+  }
+  let askedTheOperator = false;
+  for (const p of pendingConfirmation) {
+    let proceed = true;
+    if (input.confirmExistingTriggerPrincipal) {
+      askedTheOperator = true;
+      proceed = await input.confirmExistingTriggerPrincipal({
+        contextId: blueprint.contextId,
+        triggerName: p.triggerName,
+        userId: p.userId,
+        externalId: p.externalId,
+        provenance: p.provenance,
+        markedBy: p.markedBy,
+        userType: p.userType
+      });
+    }
+    if (!proceed) {
+      throw new ExistingTriggerPrincipalNotConfirmedError(
+        blueprint.contextId,
+        p.triggerName,
+        p.userId,
+        p.externalId,
+        p.provenance,
+        p.markedBy
+      );
+    }
+    if (input.confirmExistingTriggerPrincipal) {
+      triggerPrincipalsToMark.set(p.triggerName, { externalId: p.externalId, userId: p.userId, userType: p.userType });
+    }
+  }
+  const triggerPrincipalsReused = [];
   const needsContextPinnedBootstrapForIssuers = (blueprint.issuers ?? []).length > 0;
-  const ctxBootstrapClient = provisioned.ctxBootstrapClient ?? (needsContextPinnedBootstrapForIssuers ? input.remintBootstrapForContext ? await input.remintBootstrapForContext(blueprint.contextId) : client : void 0);
-  if (ctxBootstrapClient && !provisioned.ctxBootstrapClient && input.remintBootstrapForContext) {
+  const staleAfterPrompt = askedTheOperator && needsContextPinnedBootstrapForIssuers && !!input.remintBootstrapForContext;
+  const ctxBootstrapClient = (staleAfterPrompt ? await input.remintBootstrapForContext(blueprint.contextId) : void 0) ?? provisioned.ctxBootstrapClient ?? (needsContextPinnedBootstrapForIssuers ? input.remintBootstrapForContext ? await input.remintBootstrapForContext(blueprint.contextId) : client : void 0);
+  if (ctxBootstrapClient && (staleAfterPrompt || !provisioned.ctxBootstrapClient) && input.remintBootstrapForContext) {
     log.debug({ component: "loader", contextId: blueprint.contextId }, "re-minted context-pinned bootstrap client (issuers)");
   }
   const issuerActions = [];
@@ -18267,16 +19320,9 @@ async function runLoader(client, input) {
         `Trigger '${triggerName}' names schema '${entry.firingSource.schemaName}', which has no resolved schemaId \u2014 the schema failed to provision.`
       );
     }
-    const triggerUser = await client.identity.createUser({
-      body: {
-        externalId: triggerPrincipalExternalId(blueprint.name, triggerName),
-        type: "SERVICE",
-        payload: { displayName: `Trigger: ${triggerName}` }
-      }
-    });
-    const triggerUserId = triggerUser.id;
+    const triggerUserId = triggerPrincipalIds.get(triggerName);
     if (!triggerUserId) {
-      throw new Error(`Trigger '${triggerName}' service-principal create returned no user id.`);
+      throw new Error(`Trigger '${triggerName}' has no resolved service principal.`);
     }
     const triggerPlaceholderProfileBody = {
       principalId: `usr_${triggerUserId}`,
@@ -18341,6 +19387,44 @@ async function runLoader(client, input) {
       { component: "loader", triggerName, principalId: `usr_${triggerUserId}` },
       "trigger access profile widened to its declared grant"
     );
+    const toMark = triggerPrincipalsToMark.get(triggerName);
+    if (toMark) {
+      let reason;
+      try {
+        if (toMark.userType !== void 0 && toMark.userType !== "SERVICE") {
+          reason = `it is a ${toMark.userType} user, not a service principal`;
+        } else {
+          const fresh = await ctxClient.identity.getUser({ id: toMark.userId });
+          const payload = fresh.payload;
+          if (fresh.type !== void 0 && fresh.type !== "SERVICE") {
+            reason = `it is a ${fresh.type} user, not a service principal`;
+          } else if (payloadIsMasked(payload)) {
+            reason = "its payload is masked for this credential (a schema marks fields sensitive), so writing it back would replace real values";
+          } else {
+            await ctxClient.identity.createUser({
+              upsert: true,
+              body: {
+                externalId: toMark.externalId,
+                type: "SERVICE",
+                payload: {
+                  ...payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {},
+                  provisionedBy: blueprint.name
+                }
+              }
+            });
+          }
+        }
+      } catch (err) {
+        reason = err instanceof Error ? err.message : String(err);
+      }
+      if (reason !== void 0) {
+        log.warn(
+          { component: "loader", triggerName, reason },
+          "could not mark the confirmed trigger principal as this blueprint's; the next run will ask again"
+        );
+      }
+      triggerPrincipalsReused.push({ triggerName, externalId: toMark.externalId, marked: reason === void 0, ...reason !== void 0 ? { reason } : {} });
+    }
   }
   let triggerPrunes = [];
   let triggerPruneSkipped = [];
@@ -18363,6 +19447,18 @@ async function runLoader(client, input) {
       log
     }));
   }
+  const agentActions = declaresAgents(blueprint) ? await ensureAgents({
+    ctxClient,
+    agents: blueprint.agents ?? {},
+    blueprintName: blueprint.name,
+    contextId: blueprint.contextId,
+    allowAgentAdoption,
+    onAgentCreated,
+    onAgentSeen,
+    onAgentAttempt,
+    onAgentRefused,
+    log
+  }) : [];
   const keyName = skipKey ? "" : keyNameFor(blueprint.name, machineId);
   let keyAction = skipKey ? "skipped" : "created";
   let revokedKeyId;
@@ -18523,7 +19619,9 @@ async function runLoader(client, input) {
     schemaActions,
     roleActions,
     scriptActions,
+    agentActions,
     triggerActions,
+    triggerPrincipalsReused,
     triggerPrunes,
     triggerPruneSkipped,
     issuerActions,
@@ -18567,6 +19665,12 @@ function buildPlan(blueprint, opts = {}) {
       summary: `namespace '${ns.namespace}' (${ownerNote}${entityNote}${membershipNote}) [${BLUEPRINT_FIELD_PHASES.namespaces}-token phase]`
     });
   }
+  for (const triggerName of Object.keys(blueprint.triggers ?? {})) {
+    steps.push({
+      kind: "principal",
+      summary: `trigger '${triggerName}' principal '${triggerPrincipalExternalId(blueprint.name, triggerName)}' (SERVICE, marked as this blueprint's; an existing one without that mark needs confirmation)`
+    });
+  }
   for (const iss of blueprint.issuers ?? []) {
     const issuerUrl = sanitizeForPlanDisplay(iss.issuer);
     const jwksNote = `, jwksUri: ${sanitizeForPlanDisplay(iss.jwksUri)}`;
@@ -18638,10 +19742,6 @@ function buildPlan(blueprint, opts = {}) {
     });
   }
   for (const [triggerName, entry] of Object.entries(blueprint.triggers ?? {})) {
-    steps.push({
-      kind: "principal",
-      summary: `trigger '${triggerName}' principal '${blueprint.name}-trigger-${triggerName}' (SERVICE)`
-    });
     steps.push({
       kind: "profile",
       summary: `trigger '${triggerName}' profile: minimal placeholder grant (minted before the trigger row exists)`
@@ -18666,6 +19766,19 @@ function buildPlan(blueprint, opts = {}) {
       });
     }
   }
+  for (const [agentName, entry] of Object.entries(blueprint.agents ?? {})) {
+    const tools = (entry.tools ?? []).map((t) => t.allowWrites ? `${sanitizeForPlanDisplay(t.name, 64)} (writes)` : sanitizeForPlanDisplay(t.name, 64));
+    const parts = [`model ${sanitizeForPlanDisplay(entry.model)}`, tools.length ? `tools [${tools.join(", ")}]` : "no tools"];
+    if (entry.authority !== void 0) parts.push(`authority ${sanitizeForPlanDisplay(entry.authority, 32)}`);
+    const limits = Object.entries(entry.limits ?? {}).filter(([, v]) => v !== void 0);
+    if (limits.length) parts.push(`limits {${limits.map(([k, v]) => `${k} ${v}`).join(", ")}}`);
+    if (entry.budget?.maxInferenceCents !== void 0) parts.push(`budget ${entry.budget.maxInferenceCents} cents per run`);
+    if (entry.system) parts.push(`system prompt ${Array.from(entry.system).length} characters`);
+    steps.push({
+      kind: "agent",
+      summary: `agent '${sanitizeForPlanDisplay(agentName, 64)}' (ensure the stored definition matches: ${parts.join(", ")}; a changed definition becomes the next version) [${BLUEPRINT_FIELD_PHASES.agents}-token phase]`
+    });
+  }
   if (!opts.noKey) {
     steps.push({ kind: "key", summary: `key ${blueprint.name}-<machine> (mint 1 scoped ssk_*)` });
   }
@@ -18718,6 +19831,19 @@ function renderPlan(blueprint, steps, opts = {}) {
     `  and would break any trigger still referencing it. Remove one deliberately with`,
     `  'vectros scripts delete', after 'vectros scripts list' shows you what is there.`
   );
+  if (steps.some((s) => s.kind === "agent")) {
+    legendLines.push(
+      `  Counter-exception: an agent is never edited in place \u2014 a changed definition ADDS a new`,
+      `  immutable version, and an unchanged one writes nothing. Agents are not reconciled by`,
+      `  absence either: one this blueprint declared earlier and no longer does stays stored and`,
+      `  runnable. Retire it deliberately through the API (DELETE /v1/agents/{id}).`,
+      `  An agent that already exists and that nothing manages (made by hand) is REFUSED unless`,
+      `  --allow-agent-adoption is passed: adopting it marks it as this blueprint's and gives it`,
+      `  a new version if the definition differs. Another blueprint's agent is refused, and so`,
+      `  is a retired one. Writing agents needs 'agents:c' on the applying credential, plus`,
+      `  'agents:u' and 'agents:r' for an agent that already exists.`
+    );
+  }
   if (blueprint.issuers?.some((i) => i.restrictedToDomain === void 0)) {
     legendLines.push(
       `  Note: a newly registered issuer without restrictedToDomain starts pending verification on platform`,
@@ -18792,7 +19918,7 @@ function displayChallengeValue(value) {
   return value === void 0 ? void 0 : printable(value) ?? WITHHELD;
 }
 function renderChallengeBlock(view, ctx, now) {
-  const id = view.issuerId ?? "(unknown)";
+  const id = singleLine(String(view.issuerId ?? "(unknown)"), 100);
   const rawClaim = view.verificationClaim;
   const rawNonce = view.verificationNonce;
   const claim = rawClaim === void 0 ? "(not reported)" : printable(rawClaim) ?? WITHHELD;
@@ -18837,7 +19963,7 @@ function renderChallengeBlock(view, ctx, now) {
 `;
 }
 function renderExpiredBlock(view, ctx, rerun) {
-  const id = view.issuerId ?? "(unknown)";
+  const id = singleLine(String(view.issuerId ?? "(unknown)"), 100);
   const expired = view.verificationExpiresAt === void 0 ? "(unknown)" : printable(view.verificationExpiresAt) ?? WITHHELD;
   const lines = [];
   lines.push(`  \u2716 issuer '${id}' is STILL pending verification and its challenge EXPIRED at ${expired} (by this machine's clock).`);
@@ -20972,6 +22098,7 @@ function parseBootstrapArgs(argv) {
     noSeed: false,
     allowTenantWideNamespaces: false,
     allowScriptAdoption: false,
+    allowAgentAdoption: false,
     requireVerifiedIssuers: false,
     client: "desktop",
     tenant: "live",
@@ -21040,6 +22167,9 @@ function parseBootstrapArgs(argv) {
       case "--allow-script-adoption":
         args.allowScriptAdoption = true;
         break;
+      case "--allow-agent-adoption":
+        args.allowAgentAdoption = true;
+        break;
       case "--require-verified-issuers":
         args.requireVerifiedIssuers = true;
         break;
@@ -21097,6 +22227,38 @@ function buildConfirmExistingPrincipal(args, prompt, isTty) {
     return args.confirmExistingPrincipal;
   };
 }
+function buildConfirmExistingTriggerPrincipal(args, prompt, isTty, say = (text) => void process.stdout.write(text)) {
+  const reusing = (d, how) => say(
+    `  \u26A0 reusing existing trigger service principal '${d.externalId}' (trigger '${d.triggerName}') \u2014 proceeding because ${how}.
+`
+  );
+  return async (d) => {
+    if (!args.yes && isTty) {
+      const ans = await prompt(
+        `
+  \u26A0 The service principal '${d.externalId}' for trigger '${d.triggerName}' already exists in your tenant ` + (d.userType !== void 0 && d.userType !== "SERVICE" ? `and is a ${d.userType} user, not a service principal.
+` : d.provenance === "other-blueprint" ? `and is marked as provisioned by the blueprint '${singleLine(d.markedBy ?? "", 100)}', not this one.
+` : `and carries no provenance marker (an earlier CLI release, or created by hand).
+`) + `  Continuing writes that identity's access profile to this blueprint's trigger grant, and marks it as
+  this blueprint's. Expected when you re-apply a blueprint you already manage. If you don't recognize
+  this identity, do NOT proceed: it may be a name collision with something you don't control.
+  Proceed and use it? [y/N]: `
+      );
+      const ok = existingPrincipalConfirmed(ans);
+      if (ok) reusing(d, "you confirmed it at the prompt");
+      return ok;
+    }
+    if (args.confirmExistingPrincipal) reusing(d, "--confirm-existing-principal was passed");
+    return args.confirmExistingPrincipal;
+  };
+}
+function triggerPrincipalMarkLines(reused) {
+  return (reused ?? []).map(
+    (r) => r.marked ? `  \u2714 '${r.externalId}' is now marked as this blueprint's, so the next run will not ask again.
+` : `  \u26A0 '${r.externalId}' was NOT marked as this blueprint's (${singleLine(asText(r.reason ?? "unknown reason"), 300)}), so the next run will ask again.
+`
+  ).join("");
+}
 function seedSummaryLine(opts) {
   if (opts.noSeed) {
     return opts.declinedInteractively ? "  \u2714 Seeded 0 record(s) \u2014 skipped (you declined sample data)\n" : "  \u2714 Seeded 0 record(s) \u2014 skipped (--no-seed)\n";
@@ -21107,7 +22269,7 @@ function seedSummaryLine(opts) {
 function seedIndexWarningBlock(failures) {
   if (failures.length === 0) return "";
   const lines = failures.map((f) => {
-    const reason = f.message ?? f.code ?? "indexing failed";
+    const reason = singleLine(asText(f.message ?? f.code ?? "indexing failed"), 300);
     return `      \u2022 ${f.typeName}/${f.externalId} (${f.surface}): ${reason}
 `;
   });
@@ -21175,6 +22337,22 @@ function scriptTally(items) {
   if (unchanged) seg.push(`${unchanged} already current \u2014 nothing written`);
   return `${items.length} script${items.length === 1 ? "" : "s"} (${seg.join("; ")})`;
 }
+function agentTally(items) {
+  if (items.length === 0) return null;
+  const seg = items.map((i) => {
+    switch (i.action) {
+      case "created":
+        return `'${i.name}' created at version ${i.version}`;
+      case "unchanged":
+        return `'${i.name}' unchanged at version ${i.version}`;
+      case "versioned":
+        return `'${i.name}' version ${i.previousVersion} -> ${i.version}`;
+      case "adopted":
+        return i.previousVersion === i.version ? `'${i.name}' adopted (marked as this blueprint's, unchanged at version ${i.version})` : `'${i.name}' adopted (marked as this blueprint's, version ${i.previousVersion} -> ${i.version})`;
+    }
+  });
+  return `${items.length} agent${items.length === 1 ? "" : "s"} (${seg.join("; ")})`;
+}
 function applyOutcomeSummary(result, opts = {}) {
   const parts = [
     reconcileTally(result.schemaActions, "schema"),
@@ -21191,13 +22369,15 @@ function applyOutcomeSummary(result, opts = {}) {
     // wording applies unchanged; buildPlan's dry-run preview already discloses each trigger's own
     // steps individually, this is the apply-time tally counterpart.
     reconcileTally(result.triggerActions, "trigger"),
+    // Agents — written after the triggers, so reported after them.
+    agentTally(result.agentActions),
     `profile ${result.profileAction}`
   ].filter((p) => p !== null);
   const detail = parts.length ? ` \u2014 ${parts.join("; ")}` : "";
   const principalNote = (opts.principalNote ?? true) && result.userAction === "reconciled" ? `  \u26A0 service principal already existed in this tenant before this run (not newly created)
 ` : "";
   const pruneNotes = result.triggerPrunes.map(
-    (p) => `  \u26A0 trigger '${p.name}' removed from the blueprint \u2014 de-provisioned (rule + access profile deleted)
+    (p) => `  \u26A0 trigger '${singleLine(asText(p.name), 100)}' removed from the blueprint \u2014 de-provisioned (rule + access profile deleted)
 ` + // Not a warning: 404 on the profile means it was already gone, so the end state is exactly
     // what a clean prune produces. Said out loud only so the absent second delete isn't read as
     // a silent skip. Every OTHER profile-delete failure lands in triggerPruneSkipped instead.
@@ -21205,9 +22385,9 @@ function applyOutcomeSummary(result, opts = {}) {
 `)
   ).join("");
   const pruneSkippedNotes = result.triggerPruneSkipped.map(
-    (s) => s.failed === false ? s.name ? `  \u2139 trigger '${s.name}' is not declared here and was left in place \u2014 ${s.reason}.
+    (s) => s.failed === false ? s.name ? `  \u2139 trigger '${singleLine(asText(s.name), 100)}' is not declared here and was left in place \u2014 ${s.reason}.
 ` : `  \u2139 a trigger rule was left in place \u2014 ${s.reason}.
-` : s.name ? `  \u26A0 trigger '${s.name}' is no longer declared but could NOT be removed \u2014 ${s.reason}. It is still live.
+` : s.name ? `  \u26A0 trigger '${singleLine(asText(s.name), 100)}' is no longer declared but could NOT be removed \u2014 ${s.reason}. It is still live.
 ` : `  \u26A0 triggers could not be reconciled this run \u2014 ${s.reason}. A trigger removed from this blueprint may still be live.
 `
   ).join("");
@@ -21360,7 +22540,7 @@ async function runBootstrapCli(argv, deps = {}) {
   try {
     args = parseBootstrapArgs(argv);
   } catch (err) {
-    process.stderr.write(`${redactCredentials(err instanceof Error ? err.message : String(err))}
+    process.stderr.write(`${redactCredentials(errorText(err))}
 
 ${BOOTSTRAP_HELP}
 `);
@@ -21492,7 +22672,7 @@ ${IDENTITIES_TO_ENSURE_HEADING}
       if (!keyring) {
         process.stderr.write(
           `
-  \u26A0 Could not open the keyring (${keyringOpenError instanceof Error ? keyringOpenError.message : String(keyringOpenError)}).
+  \u26A0 Could not open the keyring (${errorText(keyringOpenError)}).
     Falling back to embedding the raw secret directly in the MCP config \u2014 this is NOT
     login-gated. Run \`vectros keyring doctor\` once it's fixed.
 `
@@ -21533,7 +22713,7 @@ ${IDENTITIES_TO_ENSURE_HEADING}
       } catch (err) {
         process.stderr.write(
           `
-  \u26A0 Could not store this key in the keyring (${err instanceof Error ? err.message : String(err)}).
+  \u26A0 Could not store this key in the keyring (${errorText(err)}).
     Falling back to embedding the raw secret directly in the MCP config \u2014 this is NOT
     login-gated. Run \`vectros keyring doctor\` to see why the store failed.
 `
@@ -21565,10 +22745,12 @@ ${IDENTITIES_TO_ENSURE_HEADING}
       rotate: args.rotate,
       skipSeed: noSeed,
       allowScriptAdoption: args.allowScriptAdoption,
+      allowAgentAdoption: args.allowAgentAdoption,
       readExistingKey,
       persistMintedKey,
       provisioned,
       remintBootstrapForContext,
+      confirmExistingTriggerPrincipal: buildConfirmExistingTriggerPrincipal(args, promptCtx.prompt, isTty),
       remintForContext: buildRemintForContext({
         cognitoToken,
         apiBaseUrl: baseUrl,
@@ -21577,6 +22759,7 @@ ${IDENTITIES_TO_ENSURE_HEADING}
       }),
       log
     });
+    process.stdout.write(triggerPrincipalMarkLines(result.triggerPrincipalsReused));
     const finishApply = () => finishIssuers(
       result.issuerActions,
       { context: blueprint.contextId, tenant: args.tenant, env: args.env, baseUrl: args.baseUrl },
@@ -21645,7 +22828,7 @@ ${codeAddHint}`);
         codeAddHint
       );
     } catch (err) {
-      process.stderr.write(`  \u26A0 Could not merge config (${err instanceof Error ? err.message : String(err)}).
+      process.stderr.write(`  \u26A0 Could not merge config (${errorText(err)}).
 `);
       process.stdout.write(`
   Add this manually instead:
@@ -21657,24 +22840,37 @@ ${codeAddHint}`);
   } catch (err) {
     if (err instanceof SessionExpiredError) {
       process.stderr.write(`
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
 `);
       return 2;
     }
     if (err instanceof LostKeyError) {
       process.stderr.write(`
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
 `);
       return 3;
     }
     if (err instanceof ExistingPrincipalNotConfirmedError) {
       process.stderr.write(
         `
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
 
   If this is expected (a re-apply, or a deliberate second machine for an integration you already own),
   re-run with --confirm-existing-principal, or confirm interactively.
   If you don't recognize this identity, investigate the blueprint's servicePrincipal.externalId before re-running.
+`
+      );
+      return 3;
+    }
+    if (err instanceof ExistingTriggerPrincipalNotConfirmedError) {
+      process.stderr.write(
+        `
+  \u2716 ${errorText(err)}
+
+  If this is expected (a re-apply of a blueprint you manage), re-run with --confirm-existing-principal,
+  or confirm interactively; the principal is then marked as this blueprint's and not asked about again.
+  If you don't recognize this identity, investigate the trigger's service principal first.
+  No schema, role, access profile, trigger, key or seed record was written.
 `
       );
       return 3;
@@ -21682,7 +22878,7 @@ ${codeAddHint}`);
     if (err instanceof BlueprintIdentityError || err instanceof UnresolvedIdentitiesError) {
       process.stderr.write(
         `
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
   The app-context, service principal, and any declared namespaces were already provisioned. No schemas, profile, roles, key, or seed records were.
 `
       );
@@ -21691,7 +22887,7 @@ ${codeAddHint}`);
     if (err instanceof IssuerScopeNotAppliedError) {
       process.stderr.write(
         `
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
   The app-context, service principal, and any declared namespaces were already provisioned. No schemas, profile, roles, key, or seed records were.
 `
       );
@@ -21699,7 +22895,7 @@ ${codeAddHint}`);
     }
     if (err instanceof TenantWideNamespacesNotAllowedError) {
       process.stderr.write(`
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
   Nothing was provisioned.
 `);
       return 2;
@@ -21707,7 +22903,7 @@ ${codeAddHint}`);
     process.stderr.write(`
 ${formatCliError(err, { action: "Bootstrap failed" })}`);
     if (process.env.VECTROS_MCP_DEBUG && err instanceof Error && err.stack) {
-      process.stderr.write(`${err.stack}
+      process.stderr.write(`${cleanBlock(err.stack)}
 `);
     }
     return 1;
@@ -21732,6 +22928,7 @@ function parseApplyArgs(argv) {
     seed: false,
     allowTenantWideNamespaces: false,
     allowScriptAdoption: false,
+    allowAgentAdoption: false,
     requireVerifiedIssuers: false,
     confirmExistingPrincipal: false,
     prune: false,
@@ -21792,6 +22989,9 @@ function parseApplyArgs(argv) {
       case "--allow-script-adoption":
         args.allowScriptAdoption = true;
         break;
+      case "--allow-agent-adoption":
+        args.allowAgentAdoption = true;
+        break;
       case "--require-verified-issuers":
         args.requireVerifiedIssuers = true;
         break;
@@ -21864,16 +23064,18 @@ Usage:
                           [--set name=value ...] [--values <file>] [--seed]
                           [--confirm-existing-principal] [--require-verified-issuers]
                           [--allow-tenant-wide-namespaces] [--allow-script-adoption]
+                          [--allow-agent-adoption]
                           [--token <t> | env VECTROS_BOOTSTRAP_TOKEN] [--base-url <url>]
 
 <file|name> is a path to your own blueprint (YAML/JSON) or the name of a bundled one
 (${BLUEPRINT_NAMES.join(", ")}). Everything it declares is created or reconciled \u2014 the context, its
-service principal and access profile, schemas, roles, issuers, triggers and scripts (and, only with --seed, its
+service principal and access profile, schemas, roles, issuers, triggers, scripts and agents (and, only with --seed, its
 sample seed records) \u2014 but NO scoped key is minted, nothing is written to a keyring and no MCP client config is
 touched, so a CI runner can re-apply a changed blueprint. To also get a credential, use 'vectros bootstrap'. It
 authenticates the same way bootstrap does and refuses on the same gates (scope, capability, tenant-wide namespaces)
 before anything changes. (A script pushed onto an existing hand-authored name is checked when the scripts are
-pushed, partway through: --allow-script-adoption.)
+pushed, partway through: --allow-script-adoption. An agent that exists with no blueprint mark is checked when the
+agents are written, also partway through: --allow-agent-adoption.)
 
 Before it changes anything it prints the account, tenant, context and API it is pointed at, then the plan, and
 asks to proceed unless --yes is given. With no terminal --yes is required.
@@ -21908,7 +23110,7 @@ Exit codes:
   3  needs a confirmation it did not get (an existing service principal: --confirm-existing-principal)
   4  applied in full, but --require-verified-issuers was given and an issuer is pending verification`;
 function blueprintRefusal(err) {
-  const message = err instanceof Error ? err.message : String(err);
+  const message = errorText(err);
   if (message.startsWith("Unknown blueprint ")) {
     return `No bundled blueprint matches the argument you gave. Bundled blueprints: ${BLUEPRINT_NAMES.join(", ")} (or pass a path like ./my.yaml).`;
   }
@@ -21929,7 +23131,7 @@ async function runApplyCli(argv, deps = {}) {
   } catch (err) {
     process.stderr.write(
       `
-  \u2716 ${redactCredentials(err instanceof Error ? err.message : String(err))}
+  \u2716 ${redactCredentials(errorText(err))}
   See 'vectros blueprint apply --help'. Nothing was changed.
 `
     );
@@ -21959,7 +23161,7 @@ async function runApplyCli(argv, deps = {}) {
   try {
     baseUrl = envToBaseUrl(args.env, args.baseUrl ?? process.env.VECTROS_API_BASE_URL);
   } catch (err) {
-    return refuse(err instanceof Error ? err.message : String(err));
+    return refuse(errorText(err));
   }
   const promptCtx = deps.createPrompt ? deps.createPrompt() : (() => {
     const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
@@ -21995,7 +23197,7 @@ async function runApplyCli(argv, deps = {}) {
     try {
       cognitoToken = await resolveBridgeCognitoToken(args, promptCtx.prompt, isTty, deps.resolveCognitoToken);
     } catch (err) {
-      return refuse(err instanceof Error ? err.message : String(err));
+      return refuse(errorText(err));
     }
     const mintBridge = deps.mintBridgeToken ?? mintBridgeToken;
     const mintContext = deps.mintContextToken ?? mintContextToken;
@@ -22113,6 +23315,7 @@ ${formatCliError(err, { action: "Could not mint a fresh bootstrap token after yo
       client,
       log
     );
+    const confirmTriggerPrincipal = buildConfirmExistingTriggerPrincipal(args, promptCtx.prompt, isTty);
     const result = await (deps.runLoader ?? runLoader)(client, {
       blueprint: resolvedBlueprint,
       tenantId,
@@ -22122,14 +23325,17 @@ ${formatCliError(err, { action: "Could not mint a fresh bootstrap token after yo
       // Off unless asked for: apply never deletes on its own. `blueprint-test` sets the same switch off.
       pruneTriggers: args.prune,
       allowScriptAdoption: args.allowScriptAdoption,
+      allowAgentAdoption: args.allowAgentAdoption,
       readExistingKey: async () => void 0,
       persistMintedKey: async () => {
       },
       provisioned,
       remintBootstrapForContext,
+      confirmExistingTriggerPrincipal: confirmTriggerPrincipal,
       remintForContext: buildRemintForContext({ cognitoToken, apiBaseUrl: baseUrl, tenant, mintContext }),
       log
     });
+    process.stdout.write(triggerPrincipalMarkLines(result.triggerPrincipalsReused));
     process.stdout.write(
       applyOutcomeSummary(result, { principalNote: false }) + `  \u2714 Applied '${blueprint.name}' to the ${tenant} tenant, context '${blueprint.contextId}'. No scoped key was minted and no client configuration was touched.
 ` + applySeedSummary(blueprint, args.seed, result.seededCount) + seedIndexWarningBlock(result.seedIndexFailures) + (args.prune ? "" : `  \u2139 Triggers were not pruned (--prune was not passed): a trigger this blueprint provisioned earlier and its file no longer declares is left in place. Pass --prune to remove it.
@@ -22162,12 +23368,26 @@ function reportApplyError(err) {
   if (err instanceof ExistingPrincipalNotConfirmedError) {
     process.stderr.write(
       `
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
 
   If this is expected (a re-apply of a blueprint you manage), re-run with --confirm-existing-principal
   (with --yes in a pipeline, where it is standing consent), or confirm at the prompt.
   If you don't recognize this identity, investigate the blueprint's servicePrincipal.externalId first.
   Only the principal lookup had run; no context, grant or anything else was created or changed.
+`
+    );
+    return 3;
+  }
+  if (err instanceof ExistingTriggerPrincipalNotConfirmedError) {
+    process.stderr.write(
+      `
+  \u2716 ${errorText(err)}
+
+  If this is expected (a re-apply of a blueprint you manage), re-run with --confirm-existing-principal
+  (with --yes in a pipeline, where it is standing consent), or confirm at the prompt; the principal is then
+  marked as this blueprint's and not asked about again.
+  If you don't recognize this identity, investigate the trigger's service principal first.
+  No schema, role, access profile, trigger or seed record was written.
 `
     );
     return 3;
@@ -22175,7 +23395,7 @@ function reportApplyError(err) {
   if (err instanceof BlueprintIdentityError || err instanceof UnresolvedIdentitiesError) {
     process.stderr.write(
       `
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
   The app-context, service principal, and any declared namespaces were already provisioned. No schemas, profile, roles or seed records were.
 `
     );
@@ -22184,7 +23404,7 @@ function reportApplyError(err) {
   if (err instanceof IssuerScopeNotAppliedError) {
     process.stderr.write(
       `
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
   The app-context, service principal, and any declared namespaces were already provisioned. No schemas, profile, roles or seed records were.
 `
     );
@@ -22192,7 +23412,7 @@ function reportApplyError(err) {
   }
   if (err instanceof TenantWideNamespacesNotAllowedError) {
     process.stderr.write(`
-  \u2716 ${err.message}
+  \u2716 ${errorText(err)}
   Nothing was changed.
 `);
     return 2;
@@ -22203,7 +23423,7 @@ ${formatCliError(err, { action: "Apply failed" })}  The apply stopped part-way:
 `
   );
   if (process.env.VECTROS_MCP_DEBUG && err instanceof Error && err.stack) {
-    process.stderr.write(`${err.stack}
+    process.stderr.write(`${cleanBlock(err.stack)}
 `);
   }
   return 1;
@@ -22211,6 +23431,8 @@ ${formatCliError(err, { action: "Apply failed" })}  The apply stopped part-way:
 
 // src/lint.ts
 var ENUM_COMPATIBLE_TYPES = /* @__PURE__ */ new Set(["enum", "string", "string[]"]);
+var PLATFORM_RESERVED_PAYLOAD_FIELD_NAMES = ["externalId", "partnerUserId", "scopes", "userId"];
+var PAYLOAD_RESERVING_SURFACES = ["record", "document"];
 var BUILT_IN_SORT_BY = /* @__PURE__ */ new Set(["createdAt", "lastUpdated"]);
 function lookupFieldNames(lf) {
   if (typeof lf === "string") return [lf];
@@ -22284,6 +23506,17 @@ function lintBlueprint(bp) {
       }
       fieldIds.add(f.fieldId);
       fieldsById.set(f.fieldId, f);
+      if (PLATFORM_RESERVED_PAYLOAD_FIELD_NAMES.includes(f.fieldId) && (schema.allowedSurfaces ?? ["record"]).some((surface) => PAYLOAD_RESERVING_SURFACES.includes(surface))) {
+        const seeds = (bp.seed ?? []).filter((rec) => rec.typeName === schema.typeName);
+        const seedSetsIt = seeds.some((rec) => Object.prototype.hasOwnProperty.call(rec.fields ?? {}, f.fieldId));
+        const seedsFail = seedSetsIt || f.required === true && seeds.some((rec) => rec.fields !== void 0);
+        const hint = f.fieldId === "externalId" || f.fieldId === "scopes" ? `'${f.fieldId}' is a top-level field of a record or document, and a seed sets it at the top level of the seed, not as a schema field. ` : `Choose a different fieldId. `;
+        findings.push({
+          severity: "warning",
+          rule: "reserved-payload-field-name",
+          message: `schema '${schema.typeName}', field '${f.fieldId}': the platform reserves '${f.fieldId}' (with ${PLATFORM_RESERVED_PAYLOAD_FIELD_NAMES.filter((n) => n !== f.fieldId).join(", ")}) for the top level of a record or document, so a payload that carries it is refused and this field can never hold a value. ` + hint + (seedsFail ? `This schema's seed(s) will fail when they are provisioned (a seed that sets it, or a required field the seed cannot fill). Remove the field.` : f.required === true ? `The field is required, so every write to this schema will fail. Remove the field.` : `No seed trips it today, but any write that sets it will fail. Remove the field.`)
+        });
+      }
       if (f.enumValues && f.enumValues.length > 0 && !ENUM_COMPATIBLE_TYPES.has(f.fieldType)) {
         findings.push({
           severity: "warning",
@@ -22300,6 +23533,13 @@ function lintBlueprint(bp) {
     }
     for (const lf of schema.lookupFields ?? []) {
       for (const name of lookupFieldNames(lf)) {
+        if (PLATFORM_RESERVED_PAYLOAD_FIELD_NAMES.includes(name)) {
+          findings.push({
+            severity: "error",
+            rule: "reserved-lookup-field-name",
+            message: `schema '${schema.typeName}': lookupField '${name}' is a name the platform reserves (${PLATFORM_RESERVED_PAYLOAD_FIELD_NAMES.join(", ")}), so it refuses the schema when it is created. A record is found by externalId through its own top-level externalId; choose a different name for an unrelated payload identifier.`
+          });
+        }
         if (!fieldIds.has(name)) {
           findings.push({
             severity: "error",
@@ -22518,7 +23758,7 @@ schemas:
     lookupFields: [title]      # extra O(1) exact-match lookup indexes (max 10)
 
 accessProfile:
-  # SCOPE GATE: data-plane only (records/schemas/search/documents/folders/inference/entities),
+  # SCOPE GATE: data-plane only (records/schemas/search/documents/folders/inference/entities/runs),
   # PLUS profiles:r/u/d (bounded by the platform to redistributing access you already have,
   # never granting more), profiles:c:self (create a profile for yourself only \u2014 the
   # platform resolves "self" from the caller, not from anything you declare here) and
@@ -22544,7 +23784,7 @@ accessProfile:
   dataScope: {}
   # capabilities is a SEPARATE gated dimension from allowedActions \u2014 named platform
   # effects a resource:ops verb can't express. Only 'member-lifecycle' and
-  # 'delegate-principal-stamp' are admitted today; every other name is REJECTED, same
+  # 'delegate-principal-stamp' are admitted; every other name is REJECTED, same
   # posture as the scope gate above. 'member-lifecycle' is also what lets this clause
   # carry a bare profiles:c.
   # capabilities: [member-lifecycle]
@@ -22675,7 +23915,7 @@ async function resolveAndValidate(arg, verb, supplied) {
   try {
     blueprint = await resolveBlueprintArg(arg, supplied);
   } catch (err) {
-    process.stderr.write(`  \u2716 ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`  \u2716 ${errorText(err)}
 `);
     return null;
   }
@@ -22702,7 +23942,7 @@ async function resolveAndValidate(arg, verb, supplied) {
   for (const f of findings) {
     const mark = f.severity === "error" ? "\u2716" : "\u26A0";
     const stream = f.severity === "error" ? process.stderr : process.stdout;
-    stream.write(`  ${mark} [${f.rule}] ${f.message}
+    stream.write(`  ${mark} [${f.rule}] ${singleLine(f.message, 2e3)}
 `);
   }
   if (!lintPasses(findings)) {
@@ -22717,7 +23957,7 @@ async function runValidate(args) {
   try {
     supplied = await buildInputSupply(args.set, args.values);
   } catch (err) {
-    process.stderr.write(`  \u2716 ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`  \u2716 ${errorText(err)}
 `);
     return 2;
   }
@@ -22729,6 +23969,13 @@ async function runValidate(args) {
   process.stdout.write(
     `  \u2714 '${blueprint.name}' is valid \u2014 structural \u2713, scope gate \u2713 [${effectiveAccessProfileActions(blueprint).join(", ")}]${roleNote}` + (capGate.accepted.length ? `, capability gate \u2713 [${capGate.accepted.join(", ")}]` : "") + `, lint \u2713` + (warnCount ? ` (${warnCount} warning${warnCount === 1 ? "" : "s"})` : "") + "\n"
   );
+  if (declaresAgents(blueprint)) {
+    const n = Object.keys(blueprint.agents ?? {}).length;
+    process.stdout.write(
+      `  \u2714 The 'agents' section is valid (${n} agent${n === 1 ? "" : "s"}). 'apply' creates each through POST /v1/agents, which needs the 'agents:c' scope on the credential that applies it ('agents:u' and 'agents:r' as well for an agent that already exists).
+`
+    );
+  }
   return 0;
 }
 async function runPlan(args) {
@@ -22736,13 +23983,20 @@ async function runPlan(args) {
   try {
     supplied = await buildInputSupply(args.set, args.values);
   } catch (err) {
-    process.stderr.write(`  \u2716 ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`  \u2716 ${errorText(err)}
 `);
     return 2;
   }
   const blueprint = await resolveAndValidate(args.file, "plan", supplied);
   if (!blueprint) return 2;
-  const steps = buildPlan(blueprint);
+  let steps;
+  try {
+    steps = buildPlan(blueprint);
+  } catch (err) {
+    process.stderr.write(`  \u2716 ${errorText(err)}
+`);
+    return 2;
+  }
   process.stdout.write(`
 ${renderPlan(blueprint, steps)}
 `);
@@ -22812,7 +24066,7 @@ async function runInit(args) {
   try {
     await (0, import_promises3.writeFile)(outPath, scaffold, "utf8");
   } catch (err) {
-    process.stderr.write(`  \u2716 Could not write ${outPath}: ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`  \u2716 Could not write ${outPath}: ${errorText(err)}
 `);
     return 2;
   }
@@ -22845,7 +24099,7 @@ async function runBlueprintCli(argv, deps = {}) {
   try {
     args = parseBlueprintArgs(argv);
   } catch (err) {
-    process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`${errorText(err)}
 
 ${BLUEPRINT_HELP}
 `);
@@ -25870,100 +27124,338 @@ async function runScriptsList(opts, deps = {}) {
       }
       process.stdout.write(
         "\n" + formatTable(rows, [
-          { header: "name", get: (s) => s.name },
-          { header: "version", get: (s) => s.scriptVersion === void 0 ? void 0 : String(s.scriptVersion) },
-          { header: "id", get: (s) => s.id },
-          { header: "bytes", get: (s) => s.source === void 0 ? void 0 : String(utf8Bytes2(s.source)) },
-          { header: "createdAt", get: (s) => s.createdAt }
-        ]) + "\n"
+          { header: "name", get: (s) => s.name },
+          { header: "version", get: (s) => s.scriptVersion === void 0 ? void 0 : String(s.scriptVersion) },
+          { header: "id", get: (s) => s.id },
+          { header: "bytes", get: (s) => s.source === void 0 ? void 0 : String(utf8Bytes2(s.source)) },
+          { header: "createdAt", get: (s) => s.createdAt }
+        ]) + "\n"
+      );
+      return 0;
+    } catch (err) {
+      process.stderr.write(formatCliError(err, { action: "scripts list failed" }));
+      return 1;
+    }
+  });
+}
+async function runScriptsGet(opts, deps = {}) {
+  return withAuth(opts, deps, async (auth) => {
+    const client = auth.client;
+    try {
+      const script = await client.scripts.getScript({ id: opts.id });
+      if (opts.json) {
+        process.stdout.write(`${formatJson(script)}
+`);
+        return 0;
+      }
+      process.stdout.write(`
+${renderScript(script, { source: true })}
+`);
+      return 0;
+    } catch (err) {
+      process.stderr.write(formatCliError(err, { action: "scripts get failed" }));
+      return 1;
+    }
+  });
+}
+async function runScriptsDelete(opts, deps = {}) {
+  process.stderr.write(
+    `
+  \u26A0 Deleting script version '${opts.id}' is permanent \u2014 the stored source is the only copy.
+    Other versions of the same name are unaffected.
+    The platform refuses this delete if a trigger rule still references this version \u2014
+    directly, or via 'latest' if this is the name's current newest version \u2014 and names the
+    offending rule instead of deleting. If no rule references it, the delete proceeds.
+    And if this is the name's LATEST version, its identity is REUSED: the next push of that
+    name recomputes the same version number and the same id, so anything holding a pinned
+    '${opts.id}' or a name@version reference will silently resolve to different source.
+
+`
+  );
+  if (!opts.force) {
+    const isTty = deps.isTty ?? Boolean(process.stdin.isTTY);
+    if (!isTty) {
+      process.stderr.write(
+        `  \u2716 scripts delete is irreversible and needs an interactive confirmation.
+    Re-run with --force to delete '${opts.id}' without a prompt.
+`
+      );
+      return 2;
+    }
+    const promptCtx = deps.createPrompt ? deps.createPrompt() : (() => {
+      const rl = readline8.createInterface({ input: process.stdin, output: process.stdout });
+      return { prompt: (q) => rl.question(q), close: () => rl.close() };
+    })();
+    try {
+      const typed = await promptCtx.prompt(`  Type the version id ('${opts.id}') to confirm: `);
+      if (typed.trim() !== opts.id) {
+        process.stderr.write(`  \u2716 Confirmation did not match \u2014 nothing deleted.
+`);
+        return 1;
+      }
+    } finally {
+      promptCtx.close();
+    }
+  }
+  return withAuth(opts, deps, async (auth) => {
+    const client = auth.client;
+    try {
+      await client.scripts.deleteScript({ id: opts.id });
+      if (opts.json) {
+        process.stdout.write(`${formatJson({ id: opts.id, deleted: true })}
+`);
+        return 0;
+      }
+      process.stdout.write(`  \u2714 Deleted script version '${opts.id}' from '${opts.context}'.
+`);
+      return 0;
+    } catch (err) {
+      process.stderr.write(formatCliError(err, { action: "scripts delete failed" }));
+      return 1;
+    }
+  });
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/commands/agents.ts
+var import_promises5 = require("fs/promises");
+var import_node_path6 = require("path");
+var import_yaml3 = require("yaml");
+var DEFINITION_KEYS = /* @__PURE__ */ new Set(["description", "authority", "model", "system", "tools", "limits", "budget"]);
+async function readDefinition(path4, name) {
+  let raw;
+  try {
+    raw = await (0, import_promises5.readFile)(path4, "utf8");
+  } catch (err) {
+    return { error: `could not read --file '${shortPath(path4, 300)}': ${quotedBlock(err instanceof Error ? err.message : String(err))}` };
+  }
+  let parsed;
+  try {
+    const ext = (0, import_node_path6.extname)(path4).toLowerCase();
+    parsed = ext === ".yaml" || ext === ".yml" ? (0, import_yaml3.parse)(raw, { logLevel: "error" }) : JSON.parse(raw);
+  } catch (err) {
+    return { error: `--file '${shortPath(path4, 300)}' is not valid ${/\.ya?ml$/i.test(path4) ? "YAML" : "JSON"}: ${quotedBlock(err instanceof Error ? err.message : String(err))}` };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { error: `--file '${shortPath(path4, 300)}' must hold one agent definition (an object with at least a 'model').` };
+  }
+  const entries = Object.entries(parsed);
+  const unknown = entries.map(([k]) => k).filter((k) => !DEFINITION_KEYS.has(k) && k !== "name");
+  if (unknown.length > 0) {
+    return {
+      error: `--file '${shortPath(path4, 300)}' has ${unknown.length === 1 ? "a key" : "keys"} an agent definition does not use: ${unknown.map((k) => `'${singleLine(k, 80)}'`).join(", ")}. The fields are ${[...DEFINITION_KEYS].join(", ")}.`
+    };
+  }
+  const declaredName = parsed.name;
+  if (declaredName !== void 0 && typeof declaredName !== "string") {
+    return { error: `--file '${shortPath(path4, 300)}' has a 'name' that is not a string.` };
+  }
+  if (declaredName !== void 0 && name !== void 0 && declaredName !== name) {
+    return {
+      error: `--file '${shortPath(path4, 300)}' names the agent '${singleLine(String(declaredName), 80)}', not '${name}'. Remove 'name' from the file or make them match.`
+    };
+  }
+  const { name: _name, ...definition } = parsed;
+  void _name;
+  if (typeof definition.model !== "string" || definition.model.trim().length === 0) {
+    return { error: `--file '${shortPath(path4, 300)}' needs a 'model': the id of the model the agent runs on.` };
+  }
+  if (singleLine(definition.model, definition.model.length + 1) !== definition.model) {
+    return { error: `--file '${shortPath(path4, 300)}' has a 'model' with a line break or a control character in it; a model id is plain text on one line.` };
+  }
+  return { definition, ...declaredName !== void 0 ? { declaredName } : {} };
+}
+function withHint(hint) {
+  return hint ? `    ${hint}
+` : "";
+}
+function toolsLine(a) {
+  if (!a.tools) return void 0;
+  if (a.tools.length === 0) return "(none)";
+  return a.tools.map((t) => t.allowWrites ? `${t.name} (writes)` : t.name).join(", ");
+}
+function oneLine(value, maxLength = 200) {
+  return value === void 0 ? void 0 : singleLine(value, maxLength);
+}
+function indentedBlock(value, maxLength = 1e5) {
+  if (value === void 0) return void 0;
+  return value.split(/\r\n|[\r\n\u0085\u2028\u2029]/).map((line, i) => {
+    const clean = stripControlCharacters(line.replace(/\t/g, "  "), maxLength);
+    return i === 0 || clean === "" ? clean : `      ${clean}`;
+  }).join("\n").trimEnd();
+}
+function renderAgent(a) {
+  return formatKeyValues([
+    ["id", oneLine(a.id)],
+    ["name", oneLine(a.name)],
+    ["status", oneLine(a.status)],
+    ["version", oneLine(a.version === void 0 ? void 0 : String(a.version))],
+    ["latestVersion", oneLine(a.latestVersion === void 0 ? void 0 : String(a.latestVersion))],
+    ["model", oneLine(a.model)],
+    ["authority", oneLine(a.authority)],
+    ["description", oneLine(a.description, 1e3)],
+    ["tools", oneLine(toolsLine(a), 5e3)],
+    ["limits", oneLine(a.limits === void 0 ? void 0 : JSON.stringify(a.limits), 1e3)],
+    ["budget", oneLine(a.budget === void 0 ? void 0 : JSON.stringify(a.budget), 1e3)],
+    ["provisionedBy", oneLine(a.provisionedBy)],
+    ["createdAt", oneLine(a.createdAt)],
+    ["system", indentedBlock(a.system)]
+  ]);
+}
+async function runAgentsList(opts, deps = {}) {
+  return withAuth(opts, deps, async (auth) => {
+    const client = auth.client;
+    try {
+      const rows = await drainPages(
+        (startFrom) => client.agents.listAgents({
+          contextId: opts.context,
+          limit: PAGE_LIMIT,
+          ...opts.includeRetired ? { includeRetired: true } : {},
+          ...startFrom ? { startFrom } : {}
+        })
+      );
+      if (opts.json) {
+        process.stdout.write(`${formatJson(rows)}
+`);
+        return 0;
+      }
+      if (rows.length === 0) {
+        process.stdout.write(`
+  No agents in '${opts.context}'.
+`);
+        return 0;
+      }
+      const summaryOnly = rows.every((a) => a.model === void 0);
+      process.stdout.write(
+        "\n" + formatTable(rows, [
+          { header: "name", get: (a) => oneLine(a.name) },
+          { header: "version", get: (a) => oneLine(a.latestVersion === void 0 ? void 0 : String(a.latestVersion)) },
+          { header: "status", get: (a) => oneLine(a.status) },
+          { header: "model", get: (a) => oneLine(a.model) },
+          { header: "id", get: (a) => oneLine(a.id) }
+        ]) + "\n" + (summaryOnly ? "\n  (A summary: this credential may start runs but cannot read agent definitions, which needs the 'agents:r' scope.)\n" : "")
       );
       return 0;
     } catch (err) {
-      process.stderr.write(formatCliError(err, { action: "scripts list failed" }));
+      process.stderr.write(formatCliError(sanitizedAgentError(err), { action: "agents list failed" }) + withHint(agentErrorHint(err, opts.context, "'agents:r'")));
       return 1;
     }
   });
 }
-async function runScriptsGet(opts, deps = {}) {
+async function runAgentsGet(opts, deps = {}) {
   return withAuth(opts, deps, async (auth) => {
     const client = auth.client;
     try {
-      const script = await client.scripts.getScript({ id: opts.id });
+      const agent = await client.agents.getAgent({
+        id: opts.id,
+        contextId: opts.context,
+        ...opts.version !== void 0 ? { version: opts.version } : {}
+      });
       if (opts.json) {
-        process.stdout.write(`${formatJson(script)}
+        process.stdout.write(`${formatJson(agent)}
 `);
         return 0;
       }
       process.stdout.write(`
-${renderScript(script, { source: true })}
+${renderAgent(agent)}
 `);
       return 0;
     } catch (err) {
-      process.stderr.write(formatCliError(err, { action: "scripts get failed" }));
+      process.stderr.write(formatCliError(sanitizedAgentError(err), { action: "agents get failed" }) + withHint(agentErrorHint(err, opts.context, "'agents:r'")));
       return 1;
     }
   });
 }
-async function runScriptsDelete(opts, deps = {}) {
-  process.stderr.write(
-    `
-  \u26A0 Deleting script version '${opts.id}' is permanent \u2014 the stored source is the only copy.
-    Other versions of the same name are unaffected.
-    The platform refuses this delete if a trigger rule still references this version \u2014
-    directly, or via 'latest' if this is the name's current newest version \u2014 and names the
-    offending rule instead of deleting. If no rule references it, the delete proceeds.
-    And if this is the name's LATEST version, its identity is REUSED: the next push of that
-    name recomputes the same version number and the same id, so anything holding a pinned
-    '${opts.id}' or a name@version reference will silently resolve to different source.
-
-`
-  );
-  if (!opts.force) {
-    const isTty = deps.isTty ?? Boolean(process.stdin.isTTY);
-    if (!isTty) {
-      process.stderr.write(
-        `  \u2716 scripts delete is irreversible and needs an interactive confirmation.
-    Re-run with --force to delete '${opts.id}' without a prompt.
+async function runAgentsCreate(opts, deps = {}) {
+  if (!AGENT_NAME_RE.test(opts.name)) {
+    process.stderr.write(
+      `  \u2716 '${opts.name}' is not a valid agent name \u2014 use 1-64 characters of letters, digits, underscores ('_') and hyphens ('-').
 `
-      );
-      return 2;
-    }
-    const promptCtx = deps.createPrompt ? deps.createPrompt() : (() => {
-      const rl = readline8.createInterface({ input: process.stdin, output: process.stdout });
-      return { prompt: (q) => rl.question(q), close: () => rl.close() };
-    })();
+    );
+    return 2;
+  }
+  const read = await readDefinition(opts.file, opts.name);
+  if ("error" in read) {
+    process.stderr.write(`  \u2716 ${read.error}
+`);
+    return 2;
+  }
+  return withAuth(opts, deps, async (auth) => {
+    const client = auth.client;
     try {
-      const typed = await promptCtx.prompt(`  Type the version id ('${opts.id}') to confirm: `);
-      if (typed.trim() !== opts.id) {
-        process.stderr.write(`  \u2716 Confirmation did not match \u2014 nothing deleted.
+      const agent = await client.agents.createAgent({
+        contextId: opts.context,
+        body: { ...read.definition, name: opts.name }
+      });
+      if (opts.json) {
+        process.stdout.write(`${formatJson(agent)}
 `);
-        return 1;
+        return 0;
       }
-    } finally {
-      promptCtx.close();
+      if (agent.created === false) {
+        process.stdout.write(
+          `
+  = agent '${opts.name}' already exists at version ${oneLine(String(agent.version ?? agent.latestVersion))} \u2014 nothing was written.
+  To change it, write a new version: vectros agents version ${oneLine(agent.id)} --context ${opts.context} --file <definition>
+`
+        );
+        return 0;
+      }
+      process.stdout.write(`
+  \u2714 created agent '${opts.name}' at version ${oneLine(String(agent.version ?? 1))} in '${opts.context}'
+${renderAgent(agent)}
+`);
+      return 0;
+    } catch (err) {
+      process.stderr.write(
+        formatCliError(sanitizedAgentError(err), { action: `agents create '${opts.name}' failed` }) + withHint(agentErrorHint(err, opts.context, "'agents:c'"))
+      );
+      return 1;
     }
+  });
+}
+async function runAgentsVersion(opts, deps = {}) {
+  const read = await readDefinition(opts.file);
+  if ("error" in read) {
+    process.stderr.write(`  \u2716 ${read.error}
+`);
+    return 2;
   }
   return withAuth(opts, deps, async (auth) => {
     const client = auth.client;
     try {
-      await client.scripts.deleteScript({ id: opts.id });
+      const agent = await client.agents.updateAgent({
+        id: opts.id,
+        contextId: opts.context,
+        ...opts.restore ? { restore: true } : {},
+        body: {
+          ...read.definition,
+          ...read.declaredName !== void 0 ? { name: read.declaredName } : {},
+          ...opts.expectedVersion !== void 0 ? { expectedVersion: opts.expectedVersion } : {}
+        }
+      });
       if (opts.json) {
-        process.stdout.write(`${formatJson({ id: opts.id, deleted: true })}
+        process.stdout.write(`${formatJson(agent)}
 `);
         return 0;
       }
-      process.stdout.write(`  \u2714 Deleted script version '${opts.id}' from '${opts.context}'.
-`);
+      process.stdout.write(
+        `
+  \u2714 wrote version ${oneLine(String(agent.version ?? agent.latestVersion))} of agent '${oneLine(agent.name ?? opts.id)}' in '${opts.context}'
+${renderAgent(agent)}
+`
+      );
       return 0;
     } catch (err) {
-      process.stderr.write(formatCliError(err, { action: "scripts delete failed" }));
+      process.stderr.write(
+        formatCliError(sanitizedAgentError(err), { action: `agents version '${opts.id}' failed` }) + withHint(agentErrorHint(err, opts.context, "'agents:u'"))
+      );
       return 1;
     }
   });
 }
-function errText(err) {
-  return err instanceof Error ? err.message : String(err);
-}
 
 // src/commands/assume.ts
 function parseAssumeScopes(raw) {
@@ -26224,9 +27716,11 @@ function withTimeout(p, ms) {
 }
 
 // src/commands/blueprint-test.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
+var import_node_fs6 = require("fs");
 
 // src/harness.ts
+var import_node_crypto4 = require("crypto");
 var errMsg = (e) => e instanceof Error ? e.message : String(e);
 var isNotFound2 = (e) => typeof e === "object" && e !== null && e.statusCode === 404;
 var SNAPSHOT_PAGE_SIZE = 100;
@@ -26433,7 +27927,7 @@ async function runAssertions(client, bootstrapClient, deps, blueprint, tenantId,
   }
   return assertions;
 }
-async function runTeardown(client, bootstrapClient, blueprint, machineId, snapshot, result) {
+async function runTeardown(client, bootstrapClient, blueprint, machineId, snapshot, result, runAgentNames, createdAgentIds, seenAgentNames, attemptedAgentNames, refusedAgentNames) {
   const steps = [];
   const keyName = result?.keyName ?? keyNameFor(blueprint.name, machineId);
   try {
@@ -26451,6 +27945,7 @@ async function runTeardown(client, bootstrapClient, blueprint, machineId, snapsh
   } catch (e) {
     steps.push({ step: `revoke key ${keyName}`, ok: false, error: errMsg(e) });
   }
+  steps.push(...await teardownAgents(client, blueprint, runAgentNames, createdAgentIds, seenAgentNames, attemptedAgentNames, refusedAgentNames, result));
   if (!result) return steps;
   for (const id of result.seededRecordIds) {
     try {
@@ -26644,19 +28139,247 @@ async function runTeardown(client, bootstrapClient, blueprint, machineId, snapsh
   }
   return steps;
 }
+var AGENT_RUN_SUFFIX_LENGTH = 10;
+var MAX_TESTABLE_AGENT_NAME_LENGTH = 64 - AGENT_RUN_SUFFIX_LENGTH;
+function agentRunSuffix(machineId) {
+  return `-t${(0, import_node_crypto4.createHash)("sha256").update(machineId).digest("hex").slice(0, 8)}`;
+}
+function agentNamesProblem(blueprint) {
+  const tooLong = Object.keys(blueprint.agents ?? {}).filter((name) => name.length > MAX_TESTABLE_AGENT_NAME_LENGTH);
+  if (tooLong.length === 0) return void 0;
+  return `blueprint-test gives each run its own agent names by adding ${AGENT_RUN_SUFFIX_LENGTH} characters, so an agent name can be at most ${MAX_TESTABLE_AGENT_NAME_LENGTH} characters here. Too long: ${tooLong.map((n) => `'${n}'`).join(", ")}.`;
+}
+function scopeAgentsToRun(blueprint, machineId) {
+  const declared = Object.entries(blueprint.agents ?? {});
+  if (declared.length === 0) return { blueprint, names: {} };
+  const problem = agentNamesProblem(blueprint);
+  if (problem) throw new Error(problem);
+  const suffix = agentRunSuffix(machineId);
+  const names = /* @__PURE__ */ Object.create(null);
+  const agents = /* @__PURE__ */ Object.create(null);
+  for (const [name, definition] of declared) {
+    names[name] = `${name}${suffix}`;
+    agents[names[name]] = definition;
+  }
+  return { blueprint: { ...blueprint, agents }, names };
+}
+function isAgentRemovalFailure(step) {
+  return !step.ok && /^(retire|purge) agent /.test(step.step);
+}
+async function teardownAgents(client, blueprint, runNames, createdIds, seenAgentNames, attemptedAgentNames, refusedAgentNames, result) {
+  const steps = [];
+  if (runNames.size === 0) return steps;
+  const found = new Map(createdIds);
+  const notOurs = new Set(seenAgentNames);
+  for (const a of result?.agentActions ?? []) {
+    if (!runNames.has(a.name)) continue;
+    if (a.action === "created") found.set(a.name, a.id);
+    else {
+      notOurs.add(a.name);
+      steps.push({ step: `retire agent ${a.name}`, ok: true, skipped: true, error: `skipped \u2014 this run did not create it (${a.action})` });
+    }
+  }
+  if (!result) {
+    for (const name of [...seenAgentNames].sort()) {
+      steps.push({ step: `retire agent ${name}`, ok: true, skipped: true, error: "skipped \u2014 it existed before this run created anything" });
+    }
+  }
+  const lost = new Set(
+    [...attemptedAgentNames].filter((n) => runNames.has(n) && !found.has(n) && !notOurs.has(n) && !refusedAgentNames.has(n))
+  );
+  if (lost.size > 0 && !result) {
+    let listed = false;
+    try {
+      let startFrom;
+      for (; ; ) {
+        const page = await client.agents.listAgents({ contextId: blueprint.contextId, limit: SNAPSHOT_PAGE_SIZE, startFrom });
+        for (const row of page.data ?? []) {
+          if (!row.name || !row.id || !lost.has(row.name)) continue;
+          if (row.provisionedBy === blueprint.name || row.provisionedBy === void 0) found.set(row.name, row.id);
+        }
+        if (!page.nextCursor) break;
+        startFrom = page.nextCursor;
+      }
+      listed = true;
+    } catch (e) {
+      if (isNotFound2(e)) {
+        steps.push({ step: "list agents", ok: true, skipped: true, error: "skipped \u2014 the context does not exist, so nothing was created" });
+      } else {
+        steps.push({
+          step: "list agents",
+          ok: false,
+          error: `could not list agents, so an agent created before a failure may remain: ${errMsg(e)}`
+        });
+      }
+    }
+    if (listed) {
+      for (const name of [...lost].filter((n) => !found.has(n)).sort()) {
+        steps.push({
+          step: `check agent ${name}`,
+          ok: true,
+          skipped: true,
+          error: "could not confirm whether it was created (its create got no definite answer and the listing does not show it); check with `vectros agents list --context " + blueprint.contextId + " --include-retired`"
+        });
+      }
+    }
+  }
+  for (const [name, id] of [...found].sort(([a], [b]) => a.localeCompare(b))) {
+    try {
+      await client.agents.deleteAgent({ id, contextId: blueprint.contextId });
+      steps.push({ step: `retire agent ${name}`, ok: true });
+    } catch (e) {
+      steps.push({
+        step: `retire agent ${name}`,
+        ok: false,
+        error: `the agent is still active and can be run; retire it with DELETE /v1/agents/${id} (needs agents:d): ${errMsg(e)}`
+      });
+      continue;
+    }
+    try {
+      await client.agents.deleteAgent({ id, contextId: blueprint.contextId, purge: true });
+      steps.push({ step: `purge agent ${name}`, ok: true });
+    } catch (e) {
+      steps.push({ step: `purge agent ${name}`, ok: false, error: `retired, but its content was not erased; erase it with DELETE /v1/agents/${id}?purge=true (needs agents:d): ${errMsg(e)}` });
+    }
+  }
+  return steps;
+}
+function onlyAttempted(names, attempted) {
+  const kept = Object.entries(names).filter(([, runName]) => attempted.has(runName));
+  return kept.length > 0 ? Object.fromEntries(kept) : void 0;
+}
+var HarnessInterrupted = class extends Error {
+  constructor(signal) {
+    super(`interrupted by ${signal}`);
+    this.signal = signal;
+  }
+  signal;
+};
+function watchForInterrupt(deps, run) {
+  const source = deps.signals ?? process;
+  const say = (text) => {
+    try {
+      (deps.notify ?? (() => {
+      }))(text);
+    } catch {
+    }
+  };
+  const forceExit = deps.forceExit ?? ((code) => process.exit(code));
+  let first;
+  let toreDown = false;
+  let standing = () => ({ created: /* @__PURE__ */ new Map(), inFlight: [] });
+  const heard = (signal) => {
+    if (first !== void 0) {
+      try {
+        const { created, inFlight } = standing();
+        const lines = [...created].map(([name, rawId]) => {
+          try {
+            const id = singleLine(String(rawId), 200);
+            return `    ${name}: retire it with DELETE /v1/agents/${id} (needs agents:d), then erase it with DELETE /v1/agents/${id}?purge=true
+`;
+          } catch {
+            return `    ${name}: its id could not be shown; find it with \`vectros agents list --context ${run.contextId} --include-retired\`
+`;
+          }
+        });
+        const pending = inFlight.map((name) => `    ${name}: a create was sent and not answered; find it with \`vectros agents list --context ${run.contextId} --include-retired\`
+`);
+        say(
+          `
+  \u2716 ${signal} again: leaving before teardown finished.
+` + (lines.length > 0 ? `  Agents this run created, which may still be active:
+${lines.join("")}` : "") + (pending.length > 0 ? `  Creates that may have gone through:
+${pending.join("")}` : "") + (lines.length + pending.length === 0 ? "  This run had not created, or begun to create, an agent.\n" : "") + `  Not listed: anything else the run wrote in '${run.contextId}' (schemas, roles, the access profile, a scoped key named '${run.keyName}').
+`
+        );
+      } catch {
+      }
+      forceExit(first === "SIGTERM" || signal === "SIGTERM" ? 143 : 130);
+      return;
+    }
+    first = signal;
+    say(
+      run.keep ? `
+  \u26A0 ${signal}: no further agents will be written; any other step running or still to come (a key mint, seed records) runs to its end. --keep was given, so nothing will be torn down. Send it again to leave now.
+` : toreDown ? `
+  \u26A0 ${signal}: teardown is already running and will finish. Send it again to leave now.
+` : `
+  \u26A0 ${signal}: no further agents will be written; any other step running or still to come (a key mint, seed records) runs to its end, then what this run created is torn down. Send it again to leave now.
+`
+    );
+  };
+  const onInt = () => heard("SIGINT");
+  const onTerm = () => heard("SIGTERM");
+  source.on("SIGINT", onInt);
+  source.on("SIGTERM", onTerm);
+  return {
+    get signal() {
+      return first;
+    },
+    throwIfInterrupted() {
+      if (first !== void 0) throw new HarnessInterrupted(first);
+    },
+    setAgentStanding(fn) {
+      standing = fn;
+    },
+    tearingDown() {
+      toreDown = true;
+    },
+    dispose() {
+      source.off("SIGINT", onInt);
+      source.off("SIGTERM", onTerm);
+    }
+  };
+}
 async function runBlueprintHarness(client, input, deps) {
+  const interrupt = watchForInterrupt(deps, {
+    keep: input.keep ?? false,
+    contextId: input.blueprint.contextId,
+    keyName: keyNameFor(input.blueprint.name, input.machineId)
+  });
+  try {
+    return await runHarness(client, input, deps, interrupt);
+  } catch (err) {
+    if (interrupt.signal !== void 0) {
+      let carried = err;
+      try {
+        carried = Object.assign(err !== null && typeof err === "object" ? err : new Error(String(err)), { interruptedBy: interrupt.signal });
+      } catch {
+        const shape = err;
+        let message = "unknown error";
+        try {
+          message = typeof shape?.message === "string" ? shape.message : extractServerError(err).message;
+        } catch {
+        }
+        carried = Object.assign(new Error(message, { cause: err }), {
+          interruptedBy: interrupt.signal,
+          ...shape && typeof shape === "object" && "statusCode" in shape ? { statusCode: shape.statusCode } : {},
+          ...shape && typeof shape === "object" && "body" in shape ? { body: shape.body } : {}
+        });
+      }
+      throw carried;
+    }
+    throw err;
+  } finally {
+    interrupt.dispose();
+  }
+}
+async function runHarness(client, input, deps, interrupt) {
   const { tenantId, machineId, keep = false, log, remintForContext, remintBootstrapForContext } = input;
+  const scoped = scopeAgentsToRun(input.blueprint, machineId);
+  const runBlueprintInput = scoped.blueprint;
+  const agentNames = Object.keys(scoped.names).length > 0 ? scoped.names : void 0;
   const readExistingKey = async () => void 0;
   const persistMintedKey = async () => {
   };
   const provisioned = await provisionContext(client, {
-    blueprint: input.blueprint,
+    blueprint: runBlueprintInput,
     remintBootstrapForContext,
     readExistingKey,
     log
   });
   const blueprint = await resolveApplyTimeIdentities(
-    input.blueprint,
+    runBlueprintInput,
     provisioned,
     client,
     log
@@ -26699,10 +28422,19 @@ async function runBlueprintHarness(client, input, deps) {
     existingIssuerIds: issuerSnapshot.existingIssuerIds,
     failed: contextSnapshot.failed || issuerSnapshot.failed
   };
+  const createdAgentIds = /* @__PURE__ */ new Map();
+  const seenAgentNames = /* @__PURE__ */ new Set();
+  const attemptedAgentNames = /* @__PURE__ */ new Set();
+  const refusedAgentNames = /* @__PURE__ */ new Set();
   let result;
   let assertions = [];
   let applyError;
-  try {
+  interrupt.setAgentStanding(() => ({
+    created: createdAgentIds,
+    inFlight: [...attemptedAgentNames].filter((n) => !createdAgentIds.has(n) && !seenAgentNames.has(n) && !refusedAgentNames.has(n))
+  }));
+  const applyAndAssert = (async () => {
+    interrupt.throwIfInterrupted();
     result = await runLoader(client, {
       blueprint,
       tenantId,
@@ -26713,6 +28445,13 @@ async function runBlueprintHarness(client, input, deps) {
       provisioned,
       remintForContext,
       remintBootstrapForContext,
+      onAgentCreated: ({ name, id }) => createdAgentIds.set(name, id),
+      onAgentSeen: ({ name }) => seenAgentNames.add(name),
+      onAgentAttempt: (name) => {
+        if (interrupt.signal !== void 0) return false;
+        attemptedAgentNames.add(name);
+      },
+      onAgentRefused: (name) => refusedAgentNames.add(name),
       // CREATED-ONLY, and this is the seam that keeps it true for triggers. The loader's step 5d
       // reconciles triggers by ABSENCE — it deletes rules this blueprint provisioned and no longer
       // declares. That is right for a real bootstrap run, which owns its context; it is wrong here.
@@ -26730,6 +28469,7 @@ async function runBlueprintHarness(client, input, deps) {
       // fresh, collision-free name, exactly as the harness already expects for schemas/roles/issuers.
     });
     log.debug({ component: "harness", contextId: result.contextId, keyName: result.keyName }, "applied");
+    interrupt.throwIfInterrupted();
     assertions = await runAssertions(
       await remint(blueprint.contextId),
       hasIssuers || hasNamespaces ? await remintBootstrap(blueprint.contextId) : client,
@@ -26738,10 +28478,12 @@ async function runBlueprintHarness(client, input, deps) {
       tenantId,
       result
     );
-  } catch (e) {
+  })().catch((e) => {
     applyError = errMsg(e);
     log.warn({ component: "harness", err: applyError }, "apply phase failed");
-  }
+  });
+  await applyAndAssert;
+  interrupt.tearingDown();
   let teardown = [];
   if (!keep) {
     let tdClient = client;
@@ -26756,9 +28498,22 @@ async function runBlueprintHarness(client, input, deps) {
       } catch {
       }
     }
-    teardown = await runTeardown(tdClient, tdBootstrapClient, blueprint, machineId, snapshot, result);
+    teardown = await runTeardown(
+      tdClient,
+      tdBootstrapClient,
+      blueprint,
+      machineId,
+      snapshot,
+      result,
+      new Set(Object.values(scoped.names)),
+      createdAgentIds,
+      seenAgentNames,
+      attemptedAgentNames,
+      refusedAgentNames
+    );
   }
-  const passed = applyError === void 0 && assertions.length > 0 && assertions.every((a) => a.ok);
+  const shownAgentNames = agentNames && interrupt.signal ? onlyAttempted(agentNames, attemptedAgentNames) : agentNames;
+  const passed = applyError === void 0 && assertions.length > 0 && assertions.every((a) => a.ok) && !teardown.some(isAgentRemovalFailure) && interrupt.signal === void 0;
   return {
     passed,
     applied: result ? {
@@ -26772,7 +28527,9 @@ async function runBlueprintHarness(client, input, deps) {
     assertions,
     teardown,
     kept: keep,
-    error: applyError
+    error: applyError,
+    ...shownAgentNames ? { agentNames: shownAgentNames } : {},
+    ...interrupt.signal ? { interrupted: interrupt.signal } : {}
   };
 }
 
@@ -26786,6 +28543,47 @@ async function resolveTestBlueprint(fileOrName) {
   }
   return validateBlueprint(raw);
 }
+function noticeIoForFd(fd, maxWaitMs = 2e3) {
+  return {
+    write: (bytes, offset) => (0, import_node_fs6.writeSync)(fd, bytes, offset),
+    sleep: (ms) => void Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms),
+    maxWaitMs
+  };
+}
+var stderrIo = noticeIoForFd(2);
+function writeNotice(text, io = stderrIo) {
+  const bytes = Buffer.from(text);
+  const giveUp = () => {
+    try {
+      io.write(Buffer.from("\n  [notice truncated]\n"), 0);
+    } catch {
+    }
+  };
+  let done = 0;
+  let waited = 0;
+  while (done < bytes.length) {
+    try {
+      const wrote = io.write(bytes, done);
+      if (wrote > 0) {
+        done += wrote;
+        continue;
+      }
+      if (waited >= io.maxWaitMs) return giveUp();
+      io.sleep(10);
+      waited += 10;
+    } catch (err) {
+      if (err.code !== "EAGAIN") return;
+      if (waited >= io.maxWaitMs) return giveUp();
+      io.sleep(10);
+      waited += 10;
+    }
+  }
+}
+function harnessExitCode(report) {
+  if (report.interrupted === "SIGINT") return 130;
+  if (report.interrupted === "SIGTERM") return 143;
+  return report.passed ? 0 : 1;
+}
 function renderReport(blueprint, env, report) {
   const lines = [];
   lines.push("");
@@ -26796,12 +28594,16 @@ function renderReport(blueprint, env, report) {
       `  \u2714 applied \u2014 key ${a.keyName} (${a.keyAction}), ${Object.keys(a.schemaIds).length} schema(s)` + (a.seededCount ? `, ${a.seededCount} seed(s)` : "")
     );
   } else {
-    lines.push(`  \u2716 apply failed \u2014 ${report.error ?? "unknown error"}`);
+    lines.push(`  \u2716 apply failed \u2014 ${singleLine(report.error ?? "unknown error", 600)}`);
+  }
+  if (report.agentNames && Object.keys(report.agentNames).length > 0) {
+    lines.push("  Agents ran under names of their own, so a repeat run never meets this run's agents:");
+    for (const [declared, ran] of Object.entries(report.agentNames)) lines.push(`    ${declared} \u2192 ${ran}`);
   }
   if (report.assertions.length) {
     lines.push("");
     lines.push("  Assertions:");
-    for (const a of report.assertions) lines.push(`    ${a.ok ? "\u2714" : "\u2716"} ${a.name}: ${a.detail}`);
+    for (const a of report.assertions) lines.push(`    ${a.ok ? "\u2714" : "\u2716"} ${singleLine(a.name, 200)}: ${singleLine(a.detail, 600)}`);
   }
   if (report.kept) {
     lines.push("");
@@ -26811,11 +28613,19 @@ function renderReport(blueprint, env, report) {
     lines.push("  Teardown:");
     for (const t of report.teardown) {
       const mark = !t.ok ? "\u2716" : t.skipped ? "\u21B7" : "\u2714";
-      lines.push(`    ${mark} ${t.step}${t.error ? ` \u2014 ${t.error}` : ""}`);
+      lines.push(`    ${mark} ${singleLine(t.step, 300)}${t.error ? ` \u2014 ${singleLine(t.error, 600)}` : ""}`);
     }
     const tdFail = report.teardown.filter((t) => !t.ok);
     if (tdFail.length) lines.push(`  \u26A0 ${tdFail.length} teardown step(s) failed \u2014 manual cleanup may be needed.`);
   }
+  if (report.interrupted) {
+    lines.push(
+      report.kept ? `  \u2716 Stopped by ${report.interrupted}: no further agents were written, and teardown was skipped (--keep), so what this run created is still in place. The run does not pass.` : `  \u2716 Stopped by ${report.interrupted}: no further agents were written${report.assertions.length === 0 ? " and the assertions were skipped" : ""}, and what this run created was torn down as after any failure. The run does not pass.`
+    );
+  }
+  if (report.teardown.some(isAgentRemovalFailure)) {
+    lines.push("  \u2716 An agent could not be retired or purged, so this run fails: it is still active or still holds its content.");
+  }
   lines.push("");
   lines.push(report.passed ? "  RESULT: PASS" : "  RESULT: FAIL");
   lines.push("");
@@ -26844,8 +28654,15 @@ async function runBlueprintTest(fileOrName, opts, deps = {}) {
 `);
     return 1;
   }
+  const agentNamesIssue = agentNamesProblem(blueprint);
+  if (agentNamesIssue) {
+    process.stderr.write(`  \u2716 ${agentNamesIssue}
+  Nothing was changed.
+`);
+    return 2;
+  }
   return withAuth({ ...opts, provisioning: true }, deps, async (auth, log) => {
-    const machineId = `harness-${Date.now()}-${(0, import_node_crypto4.randomUUID)().slice(0, 8)}`;
+    const machineId = `harness-${Date.now()}-${(0, import_node_crypto5.randomUUID)().slice(0, 8)}`;
     try {
       const tenantId = requireTenantId(auth);
       const client = auth.client;
@@ -26885,10 +28702,10 @@ async function runBlueprintTest(fileOrName, opts, deps = {}) {
           environment: auth.baseUrl
         });
       };
-      const report = await runBlueprintHarness(
+      const report = await (deps.runHarness ?? runBlueprintHarness)(
         client,
         { blueprint, tenantId, machineId, keep: opts.keep, log, remintForContext, remintBootstrapForContext },
-        { pingWithKey }
+        { pingWithKey, notify: deps.notify ?? ((text) => writeNotice(text)) }
       );
       if (opts.json) {
         const envelope = {
@@ -26902,10 +28719,16 @@ async function runBlueprintTest(fileOrName, opts, deps = {}) {
         process.stdout.write(`${renderReport(blueprint, auth.env, report)}
 `);
       }
-      return report.passed ? 0 : 1;
+      return harnessExitCode(report);
     } catch (err) {
-      process.stderr.write(formatCliError(err, { action: "blueprint-test failed" }));
-      return 1;
+      process.stderr.write(formatCliError(sanitizedAgentError(err), { action: "blueprint-test failed" }));
+      const by = err?.interruptedBy;
+      if (by && opts.json) {
+        const failed = { passed: false, assertions: [], teardown: [], kept: Boolean(opts.keep), error: singleLine(sanitizedAgentError(err).message, 600), interrupted: by };
+        process.stdout.write(`${formatJson({ blueprint: { name: blueprint.name, version: blueprint.version, contextId: blueprint.contextId }, env: auth.env, ...failed })}
+`);
+      }
+      return by === "SIGINT" ? 130 : by === "SIGTERM" ? 143 : 1;
     }
   });
 }
@@ -27089,9 +28912,9 @@ function emitJoined(opts) {
 
 // src/build-info.ts
 var BUILD_INFO = {
-  cli: true ? "0.26.0" : "dev",
-  sdk: true ? "0.48.0" : "dev",
-  blueprints: true ? "0.20.3" : "dev"
+  cli: true ? "0.27.0" : "dev",
+  sdk: true ? "0.49.0" : "dev",
+  blueprints: true ? "0.21.0" : "dev"
 };
 function formatBuildInfo() {
   return `vectros ${BUILD_INFO.cli} (sdk ${BUILD_INFO.sdk}, blueprints ${BUILD_INFO.blueprints})`;
@@ -27128,6 +28951,17 @@ function parseTenantFlag(raw) {
   }
   return raw;
 }
+var POSITIVE_INT_INVALID = /* @__PURE__ */ Symbol("parsePositiveInt:invalid");
+function parsePositiveInt(raw, flag) {
+  if (raw === void 0) return void 0;
+  if (!/^[1-9][0-9]{0,8}$/.test(raw)) {
+    process.stderr.write(`  \u2716 ${flag} must be a positive whole number (got '${raw}')
+`);
+    process.exitCode = 2;
+    return POSITIVE_INT_INVALID;
+  }
+  return Number(raw);
+}
 function toCommonOptions(flags) {
   return {
     env: flags.env,
@@ -27182,6 +29016,7 @@ function buildProgram(deps = {}) {
   registerDomainsCommands(program, deps);
   registerNamespaceCommands(program, deps);
   registerScriptsCommands(program, deps);
+  registerAgentsCommands(program, deps);
   registerAssumeCommand(program, deps);
   registerJoinCommand(program, deps);
   registerKeyringCommands(program);
@@ -27637,6 +29472,57 @@ function registerScriptsCommands(program, deps) {
     }
   );
 }
+function registerAgentsCommands(program, deps) {
+  const agents = program.command("agents").description("Manage stored agents (named, versioned model + prompt + tool whitelist definitions).");
+  const list = agents.command("list").description("List the agents in a context, each at its newest version.").requiredOption("--context <c>", "app context to read").option("--include-retired", "also list retired agents").option("--tenant <tenant>", "target tenant: 'test' or 'live' (default live)");
+  addCommonAuthOptions(list).action(
+    async (flags) => {
+      const tenant = parseTenantFlag(flags.tenant);
+      if (tenant === TENANT_FLAG_INVALID) return;
+      process.exitCode = await runAgentsList(
+        { ...toCommonOptions(flags), context: flags.context, includeRetired: Boolean(flags.includeRetired), tenant },
+        deps
+      );
+    }
+  );
+  const get = agents.command("get").description("Show one agent at its newest version, or at an earlier one with --at-version.").argument("<id>", "the agent's id (see `agents list`)").requiredOption("--context <c>", "app context to read").option("--at-version <n>", "show an earlier version number (the newest when omitted)").option("--tenant <tenant>", "target tenant: 'test' or 'live' (default live)");
+  addCommonAuthOptions(get).action(
+    async (id, flags) => {
+      const tenant = parseTenantFlag(flags.tenant);
+      if (tenant === TENANT_FLAG_INVALID) return;
+      const version2 = parsePositiveInt(flags.atVersion, "--at-version");
+      if (version2 === POSITIVE_INT_INVALID) return;
+      process.exitCode = await runAgentsGet(
+        { ...toCommonOptions(flags), id, context: flags.context, version: version2, tenant },
+        deps
+      );
+    }
+  );
+  const create = agents.command("create").description("Store an agent at version 1 from a definition file (an existing name is returned unchanged).").argument("<name>", "agent name: 1-64 chars of letters, digits, '_' and '-'").requiredOption("--context <c>", "app context to create it in").requiredOption("--file <path>", "JSON or YAML file holding the definition (model, system, tools, limits, budget)").option("--tenant <tenant>", "target tenant: 'test' or 'live' (default live)");
+  addCommonAuthOptions(create).action(
+    async (name, flags) => {
+      const tenant = parseTenantFlag(flags.tenant);
+      if (tenant === TENANT_FLAG_INVALID) return;
+      process.exitCode = await runAgentsCreate(
+        { ...toCommonOptions(flags), name, context: flags.context, file: flags.file, tenant },
+        deps
+      );
+    }
+  );
+  const version = agents.command("version").description("Write the next version of an agent from a definition file (a full replacement: omitted fields take their defaults).").argument("<id>", "the agent's id (see `agents list`)").requiredOption("--context <c>", "app context the agent is in").requiredOption("--file <path>", "JSON or YAML file holding the new definition").option("--expected-version <n>", "refuse the write if the agent has a newer version than this one").option("--restore", "bring a retired agent back, with this definition as its next version").option("--tenant <tenant>", "target tenant: 'test' or 'live' (default live)");
+  addCommonAuthOptions(version).action(
+    async (id, flags) => {
+      const tenant = parseTenantFlag(flags.tenant);
+      if (tenant === TENANT_FLAG_INVALID) return;
+      const expectedVersion = parsePositiveInt(flags.expectedVersion, "--expected-version");
+      if (expectedVersion === POSITIVE_INT_INVALID) return;
+      process.exitCode = await runAgentsVersion(
+        { ...toCommonOptions(flags), id, context: flags.context, file: flags.file, expectedVersion, restore: Boolean(flags.restore), tenant },
+        deps
+      );
+    }
+  );
+}
 function registerRoleCommands(program, deps) {
   const role = program.command("role").description("Manage context-scoped roles (reusable scope rules; bind via `access grant --role`).");
   const create = role.command("create").description("Create (idempotent by roleId) a single-clause role from --actions.").requiredOption("--context <c>", "app context").requiredOption("--role-id <id>", "role id (3-31 chars; lowercase letter + lowercase/digit/dash)").requiredOption("--name <name>", "human-readable name").requiredOption("--actions <csv>", "allowed actions, comma-separated (e.g. records:cru,search:r)").option(
@@ -27962,10 +29848,10 @@ async function main() {
   await buildProgram().parseAsync(process.argv);
 }
 main().catch((err) => {
-  process.stderr.write(`fatal: ${err instanceof Error ? err.message : String(err)}
+  process.stderr.write(`fatal: ${errorText(err)}
 `);
   if (process.env.VECTROS_MCP_DEBUG && err instanceof Error && err.stack) {
-    process.stderr.write(`${err.stack}
+    process.stderr.write(`${cleanBlock(err.stack)}
 `);
   }
   process.exitCode = 2;