@vectros-ai/cli 0.25.0 → 0.26.0

package/dist/cli.mjs

@@ -1634,9 +1634,11 @@ __export(api_exports, {
   BatchWriteRequest: () => BatchWriteRequest,
   BatchWriteResult: () => BatchWriteResult,
   ChatMessage: () => ChatMessage,
+  ChatRequest: () => ChatRequest,
   ConflictError: () => ConflictError,
   ContentDeltaEvent: () => ContentDeltaEvent,
   ContentTooLargeError: () => ContentTooLargeError,
+  DocumentAskRequest: () => DocumentAskRequest,
   DocumentContextEvent: () => DocumentContextEvent,
   DocumentLookupRequest: () => DocumentLookupRequest,
   DocumentPatchRequest: () => DocumentPatchRequest,
@@ -1667,8 +1669,10 @@ __export(api_exports, {
   NotImplementedError: () => NotImplementedError,
   PaymentRequiredError: () => PaymentRequiredError,
   PingResponse: () => PingResponse,
+  RagRequest: () => RagRequest,
   RagSearch: () => RagSearch,
   ReadAccessLogResponse: () => ReadAccessLogResponse,
+  ReasoningDeltaEvent: () => ReasoningDeltaEvent,
   RecordLookupRequest: () => RecordLookupRequest,
   RecordRequest: () => RecordRequest,
   RecordResponse: () => RecordResponse,
@@ -2024,7 +2028,33 @@ var ListUsersRequestOrder = {
   Asc: "asc",
   Desc: "desc"
 };
+var ChatRequest;
+((ChatRequest2) => {
+  ChatRequest2.Reasoning = {
+    Omit: "omit",
+    Stream: "stream"
+  };
+})(ChatRequest || (ChatRequest = {}));
+var DocumentAskRequest;
+((DocumentAskRequest2) => {
+  DocumentAskRequest2.Reasoning = {
+    Omit: "omit",
+    Stream: "stream"
+  };
+})(DocumentAskRequest || (DocumentAskRequest = {}));
+var RagRequest;
+((RagRequest2) => {
+  RagRequest2.Reasoning = {
+    Omit: "omit",
+    Stream: "stream"
+  };
+})(RagRequest || (RagRequest = {}));
 var inference_exports = {};
+__export(inference_exports, {
+  ChatRequest: () => ChatRequest,
+  DocumentAskRequest: () => DocumentAskRequest,
+  RagRequest: () => RagRequest
+});
 var BatchWriteRequest;
 ((BatchWriteRequest2) => {
   BatchWriteRequest2.Atomicity = {
@@ -2297,6 +2327,12 @@ var ReadAccessLogResponse;
     Rag: "rag"
   };
 })(ReadAccessLogResponse || (ReadAccessLogResponse = {}));
+var ReasoningDeltaEvent;
+((ReasoningDeltaEvent2) => {
+  ReasoningDeltaEvent2.Event = {
+    ReasoningDelta: "reasoning_delta"
+  };
+})(ReasoningDeltaEvent || (ReasoningDeltaEvent = {}));
 var RecordRequest;
 ((RecordRequest2) => {
   RecordRequest2.Status = {
@@ -4191,7 +4227,7 @@ var AuthClient = class {
     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 additionally stops credentials already bound to it, within about five minutes; suspending the user does not stop their existing keys at all. A `PENDING` user is fine.
+   * 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.
@@ -4534,6 +4570,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4586,6 +4623,8 @@ var AuthClient = class {
           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:
@@ -4669,6 +4708,8 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.PaymentRequiredError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4721,6 +4762,10 @@ var AuthClient = class {
           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 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -4809,6 +4854,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4865,6 +4911,8 @@ var AuthClient = class {
           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:
@@ -4955,6 +5003,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5005,6 +5054,8 @@ var AuthClient = class {
           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:
@@ -5151,13 +5202,14 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/app-contexts/{contextId}");
   }
   /**
-   * Updates an app context. This is a partial update: any field you omit (or send as null) keeps its existing value. The `contextId` is immutable and is taken from the URL path, so any `contextId` in the request body is ignored. Patchable fields: `name`, `description`, `companyName`; the per-principal metering trio (`meteringAxis`, `principalBurstLimit`, `principalUsageCap` — only takes effect for a partner with the corresponding account-level feature enabled); `readAccessLogDefault` (the PHI read-access-logging context default); and `identityProjectionClaims` (requires the platform provisioning capability on top of the ordinary scope below — see its own field description). Requires the `app-contexts:u` scope.
+   * Updates an app context. This is a partial update: any field you omit (or send as null) keeps its existing value. The `contextId` is immutable and is taken from the URL path, so any `contextId` in the request body is ignored. Patchable fields: `name`, `description`, `companyName`; the per-principal metering trio (`meteringAxis`, `principalBurstLimit`, `principalUsageCap` — only takes effect for an account with the corresponding feature enabled); `readAccessLogDefault` (the PHI read-access-logging context default); and `identityProjectionClaims` (requires the platform provisioning capability on top of the ordinary scope below — see its own field description). Requires the `app-contexts:u` scope.
    *
    * @param {Vectros.UpdateAppContextRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5206,6 +5258,8 @@ var AuthClient = class {
           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:
@@ -5362,6 +5416,7 @@ var AuthClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5414,6 +5469,8 @@ var AuthClient = class {
           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:
@@ -5439,6 +5496,7 @@ var AuthClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5481,6 +5539,8 @@ var AuthClient = class {
           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:
@@ -5762,6 +5822,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5808,6 +5869,8 @@ var AuthClient = class {
           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:
@@ -5821,7 +5884,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/auth/issuers/{issuerId}");
   }
   /**
-   * Deregisters a trusted third-party IdP issuer. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context may only deregister an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key may deregister any issuer. Refused if any user account was ever created or matched via this issuer (by a prior self-signup or accepted invite, through `POST /v1/auth/token/exchange`) — that access cannot be silently orphaned. This is unconditional on the affected users' `status`: suspending them first does not lift the refusal. **A bound registration cannot be replaced, self-service, within its own app context**: registering a replacement issuer under a different issuerId in the SAME context also fails, because the context's one-active-issuer claim is released only when THIS registration is deleted. Two real options: suspend this issuer (stops new exchanges immediately) and register a replacement under a DIFFERENT app context — note that targets a different context, so this context's existing users/roles/access profiles are not carried over; or contact your platform operator, who can force-release this registration so a replacement may be registered in the SAME context under a new issuerId. **The operator path is not a lighter-weight alternative to the first — it PERMANENTLY RETIRES this issuerId and leaves every bound user unable to ever exchange through it again; it does not preserve continuity for them any better than registering under a different context does.** An issuer that has never been used for an exchange (no bound users yet) can always be deregistered.
+   * Deregisters a trusted third-party IdP issuer. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context may only deregister an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key may deregister any issuer. Refused if any user account was ever created or matched via this issuer (by a prior self-signup or accepted invite, through `POST /v1/auth/token/exchange`) — that access cannot be silently orphaned. This is unconditional on the affected users' `status`: suspending them first does not lift the refusal. **A bound registration cannot be replaced, self-service, within its own app context**: registering a replacement issuer under a different issuerId in the SAME context also fails, because the context's one-active-issuer claim is released only when THIS registration is deleted. Two real options: suspend this issuer (stops new exchanges immediately) and register a replacement under a DIFFERENT app context — note that targets a different context, so this context's existing users/roles/access profiles are not carried over; or contact support, who can force-release this registration so a replacement may be registered in the SAME context under a new issuerId. **The support path is not a lighter-weight alternative to the first — it PERMANENTLY RETIRES this issuerId and leaves every bound user unable to ever exchange through it again; it does not preserve continuity for them any better than registering under a different context does.** An issuer that has never been used for an exchange (no bound users yet) can always be deregistered.
    *
    * @param {Vectros.DeleteIssuerRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -5947,7 +6010,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/auth/issuers");
   }
   /**
-   * Registers a trusted third-party IdP issuer that BYO-IdP token exchange (`POST /v1/auth/token/exchange`) may accept a `subject_token` from. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary partner-grantable scope. A credential authorized only via the provisioning capability may register only against the app context it is bound to; naming a different one returns 403. A root API key is unaffected and may register against any of its contexts. A registration without `restrictedToDomain` is created `pending_verification` with a one-time challenge (`verificationClaim`, `verificationNonce`, `verificationExpiresAt`) and accepts no token until you prove you control the issuer with `POST /v1/auth/issuers/{issuerId}/verify`; it claims no `(issuer, audience)` pair until then, so registering never reveals whether another tenant holds one. A registration scoped to an already-verified domain with `restrictedToDomain` is `active` at once. Idempotent by `issuerId` within your tenant. If `issuerId` collides with a registration owned by a different app context than the one you're confined to, the request fails with 400 rather than returning that context's configuration. An app context may have at most one active issuer — deregister the existing one first if you need to replace it. One issuer MAY serve several contexts today, each via its own registration row with a distinct `audience`. Optionally name `restrictedToDomain` to scope this registration's (issuer, audience) uniqueness to a specific VERIFIED domain rather than the bare pair — see that field's own description. A domain-scoped registration proves control of the DOMAIN, not of the issuer itself: it routes only tokens carrying that domain's `hd` claim.
+   * Registers a trusted third-party IdP issuer that BYO-IdP token exchange (`POST /v1/auth/token/exchange`) may accept a `subject_token` from. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary grantable scope. A credential authorized only via the provisioning capability may register only against the app context it is bound to; naming a different one returns 403. A root API key is unaffected and may register against any of its contexts. A registration without `restrictedToDomain` is created `pending_verification` with a one-time challenge (`verificationClaim`, `verificationNonce`, `verificationExpiresAt`) and accepts no token until you prove you control the issuer with `POST /v1/auth/issuers/{issuerId}/verify`; it claims no `(issuer, audience)` pair until then, so registering never reveals whether another tenant holds one. A registration scoped to an already-verified domain with `restrictedToDomain` is `active` at once. Idempotent by `issuerId` within your tenant. If `issuerId` collides with a registration owned by a different app context than the one you're confined to, the request fails with 400 rather than returning that context's configuration. An app context may have at most one active issuer — deregister the existing one first if you need to replace it. One issuer MAY serve several contexts, each via its own registration row with a distinct `audience`. Optionally name `restrictedToDomain` to scope this registration's (issuer, audience) uniqueness to a specific VERIFIED domain rather than the bare pair — see that field's own description. A domain-scoped registration proves control of the DOMAIN, not of the issuer itself: it routes only tokens carrying that domain's `hd` claim.
    *
    * @param {Vectros.IssuerRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6356,6 +6419,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -6403,6 +6467,8 @@ var AuthClient = class {
           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:
@@ -6502,6 +6568,7 @@ var AuthClient = class {
    * @throws {@link Vectros.UnauthorizedError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ContentTooLargeError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -6546,6 +6613,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 413:
+          throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6685,7 +6754,7 @@ var ComplianceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/erasure-requests/{id}");
   }
   /**
-   * Submits an asynchronous job to export your account's data, or a single end-subject's data, across the requested contexts. The request returns 202 with an `exportJobId`; poll `GET /v1/admin/export/{id}` until the job completes to obtain a short-lived presigned download URL and a manifest describing the payload. Requires a root API key — a scoped credential is rejected with 403.
+   * Reserved: with a root API key this operation answers `501` and starts no job. The request and response shapes are published so that integrations can be written against them: a request names the contexts, or a single end-subject, to export, and the response carries an `exportJobId` that `GET /v1/admin/export/{id}` reports on. Requires a root API key — a scoped credential is rejected with 403.
    *
    * @param {Vectros.ExportRequest} request
    * @param {ComplianceClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6746,7 +6815,7 @@ var ComplianceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/admin/export");
   }
   /**
-   * Polls an export job by id. While the job is still running this returns its status only; once it completes, the response also includes a short-lived presigned download URL and a manifest (format version and per-context counts). Requires a root API key.
+   * Reserved: with a root API key this operation answers `501`. Its response shape is the one the export operation above refers to: the job status, and a short-lived presigned download URL and a manifest (format version and per-context counts) for a completed job. Requires a root API key.
    *
    * @param {Vectros.GetExportRequest} request
    * @param {ComplianceClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6877,6 +6946,8 @@ var DocumentsClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -6928,6 +6999,10 @@ var DocumentsClient = class {
           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:
@@ -7075,6 +7150,7 @@ var DocumentsClient = class {
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -7114,6 +7190,8 @@ var DocumentsClient = class {
       switch (_response.error.statusCode) {
         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:
@@ -7406,7 +7484,7 @@ 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: always available 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 /{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, or extraction has not yet completed. Requires the `documents:r` scope.
    *
    * @param {Vectros.GetDocumentTextRequest} request
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -7526,6 +7604,7 @@ var DocumentsClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -7575,6 +7654,8 @@ var DocumentsClient = 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:
@@ -7658,6 +7739,8 @@ var FoldersClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -7707,6 +7790,10 @@ var FoldersClient = class {
           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:
@@ -7782,6 +7869,7 @@ var FoldersClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -7829,6 +7917,8 @@ var FoldersClient = class {
           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:
@@ -7849,6 +7939,7 @@ var FoldersClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -7890,6 +7981,8 @@ var FoldersClient = class {
           throw new BadRequestError(_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:
@@ -7903,7 +7996,7 @@ var FoldersClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/folders/{id}");
   }
   /**
-   * Partially updates a folder using an RFC 7386 JSON Merge Patch. The `name`, `description`, and ownership fields (`userId`, `scopes`) are applied when present and left unchanged when omitted; sending any of these as null is rejected, because clearing a field is not supported in this release (omit it instead). `slug` and `parentFolderId` are immutable — a folder cannot be re-slugged or moved via the API — and the request is rejected if either is present. Pass `expectedVersion` for optimistic concurrency (you get a 409 if the folder changed since you last read it). Requires the `folders:u` scope.
+   * Partially updates a folder using an RFC 7386 JSON Merge Patch. The `name`, `description`, and ownership fields (`userId`, `scopes`) are applied when present and left unchanged when omitted; sending any of these as null is rejected, because clearing a field is not supported (omit it instead). `slug` and `parentFolderId` are immutable — a folder cannot be re-slugged or moved via the API — and the request is rejected if either is present. Pass `expectedVersion` for optimistic concurrency (you get a 409 if the folder changed since you last read it). Requires the `folders:u` scope.
    *
    * @param {Vectros.PatchFolderRequest} request
    * @param {FoldersClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -8126,6 +8219,8 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8178,6 +8273,10 @@ var IdentityClient = class {
           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:
@@ -8258,6 +8357,7 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8310,6 +8410,8 @@ var IdentityClient = class {
           throw new BadRequestError(_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:
@@ -8329,6 +8431,7 @@ var IdentityClient = class {
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8373,6 +8476,8 @@ var IdentityClient = class {
       switch (_response.error.statusCode) {
         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:
@@ -8596,6 +8701,7 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8647,6 +8753,8 @@ var IdentityClient = class {
           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:
@@ -8667,6 +8775,7 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8711,6 +8820,8 @@ var IdentityClient = class {
           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:
@@ -8775,7 +8886,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/namespaces");
   }
   /**
-   * Registers a new scope namespace and declares whether its values resolve to identity entities (`entityBacked`). Also requires `specificityRank`, an explicit, account-unique position in the specificity order used to break recordType schema-resolution ties. Requires a root API key or one of the CLI bootstrap's two provisioning capabilities — never an ordinary partner-grantable scope. A bootstrap credential's registration is confined to its own app context UNLESS it additionally holds the tenant-wide namespace-provisioning capability and `contextId` is omitted, in which case it may register a TENANT-WIDE namespace (visible to every context). `org` and `client` are reserved names, registered the same way as any other namespace.
+   * Registers a new scope namespace and declares whether its values resolve to identity entities (`entityBacked`). Also requires `specificityRank`, an explicit, account-unique position in the specificity order used to break recordType schema-resolution ties. Requires a root API key or one of the CLI bootstrap's two provisioning capabilities — never an ordinary grantable scope. A bootstrap credential's registration is confined to its own app context UNLESS it additionally holds the tenant-wide namespace-provisioning capability and `contextId` is omitted, in which case it may register a TENANT-WIDE namespace (visible to every context). `org` and `client` are reserved names, registered the same way as any other namespace.
    *
    * @param {Vectros.RegisterNamespaceRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -8917,6 +9028,7 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8966,6 +9078,8 @@ var IdentityClient = 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:
@@ -9034,13 +9148,14 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/users/{id}");
   }
   /**
-   * Updates mutable fields on an existing user (such as email, status, payload, or schema binding). The `type` field is immutable after creation, and `email` cannot be changed while an invitation to that user is still outstanding — revoke the invitation, or invite the new address instead. This endpoint also activates an invited user: a PUT that moves a PENDING user to ACTIVE and carries `inviteToken`, `externalSubject`, and `emailVerifiedAttestation=true` completes the invitation. **`externalSubject` set this way is NOT an authentication binding and does not enable sign-in anywhere** — not the Vectros DevPortal/Admin App/web apps, and not `/v1/auth/token/exchange` either; both are granted only by the invitee authenticating themselves. If the invitee needs dev-portal/web-app access, send them the invitation link and let them accept it directly. If the invitee needs to sign in via token exchange, have them redeem `inviteToken` themselves at `/v1/auth/token/exchange` with their own credential — Vectros verifies it there and computes its own value for this field from the verified credential. The value you send here is stored exactly as-is, with no normalization, and does NOT automatically match or deduplicate against what a later token-exchange sign-in computes for the same real-world identity. Call this endpoint directly only if you run your own backend and want Vectros to record which of your own users a given account corresponds to — treat this field as informational for that purpose, not as a way to pre-authorize sign-in. Requires the `users:u` scope.
+   * Updates mutable fields on an existing user (such as email, status, payload, or schema binding). The `type` field is immutable after creation, and `email` cannot be changed while an invitation to that user is still outstanding — revoke the invitation, or invite the new address instead. This endpoint also activates an invited user: a PUT that moves a PENDING user to ACTIVE and carries `inviteToken`, `externalSubject`, and `emailVerifiedAttestation=true` completes the invitation. **`externalSubject` set this way is NOT an authentication binding and does not enable sign-in anywhere** — not the Vectros DevPortal/Admin App/web apps, and not `/v1/auth/token/exchange` either; both are granted only by the invitee authenticating themselves. A subject stored through `PUT /v1/users/{id}` does not make the person a member of your account: it is ignored for the tenant claims in sign-in tokens, the developer portal's memberships list and tenant switching, and an ownership transfer. To give such a person access, delete the user and invite them again; accepting the invitation binds the subject and counts it. If the invitee needs dev-portal/web-app access, send them the invitation link and let them accept it directly. If the invitee needs to sign in via token exchange, have them redeem `inviteToken` themselves at `/v1/auth/token/exchange` with their own credential — Vectros verifies it there and computes its own value for this field from the verified credential. The value you send here is stored exactly as-is, with no normalization, and does NOT automatically match or deduplicate against what a later token-exchange sign-in computes for the same real-world identity. Call this endpoint directly only if you run your own backend and want Vectros to record which of your own users a given account corresponds to — treat this field as informational for that purpose, not as a way to pre-authorize sign-in. Requires the `users:u` scope.
    *
    * @param {Vectros.UpdateUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -9088,6 +9203,8 @@ var IdentityClient = class {
           throw new BadRequestError(_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:
@@ -9349,7 +9466,7 @@ var InferenceClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns every inference model available to you, including each model's context window, the plan tiers it's available on, and the exact credit rates charged per 1K input and output tokens. 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, 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`.
    *
    * @param {InferenceClient.RequestOptions} requestOptions - Request-specific configuration.
    *
@@ -9393,7 +9510,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. Token cost is debited from your pre-paid inference balance (in cents), and a small per-call flat fee is debited from your monthly platform credit allowance. 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 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.
    */
   chatInference(request, requestOptions) {
     return HttpResponsePromise.fromPromise(this.__chatInference(request, requestOptions));
@@ -9446,10 +9563,14 @@ var InferenceClient = class {
           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 413:
           throw new ContentTooLargeError(_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,
@@ -9523,6 +9644,8 @@ var InferenceClient = class {
           throw new ContentTooLargeError(_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,
@@ -9587,12 +9710,16 @@ var InferenceClient = class {
           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 413:
           throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         case 500:
           throw new InternalServerError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -9670,7 +9797,7 @@ var RecordsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/records/batch-get");
   }
   /**
-   * Reserved endpoint for batch lookup and reference resolution. The published response shape correlates results to each input and carries a per-item status envelope. It currently returns 501 (not implemented). The documented 200 response schema is the stable shape this endpoint will use once available. Requires the `records:r` scope.
+   * Reserved endpoint for batch lookup and reference resolution. With the `records:r` scope it answers 501 (not implemented). The published response shape correlates results to each input and carries a per-item status envelope. Requires the `records:r` scope.
    *
    * @param {Vectros.BatchLookupRequest} request
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -9731,7 +9858,7 @@ var RecordsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/records/lookup/batch");
   }
   /**
-   * Writes up to 50 records (or 50 with `atomicity: all_or_nothing`) in a single request. Each item in `items` has exactly the same shape, and goes through exactly the same validation, authorization and idempotency rules, as the body of a single `POST /v1/records` — including schema validation, `externalId` idempotency, unique-field enforcement, and the `records:c:<type>` scope check, which is applied per item against that item's own record type. A batch is not a way to write a type your credential could not write one at a time.
+   * Writes up to 50 records per request in `best_effort` mode and up to 50 with `atomicity: all_or_nothing`, in a single request. Each item in `items` has exactly the same shape, and goes through exactly the same validation, authorization and idempotency rules, as the body of a single `POST /v1/records` — including schema validation, `externalId` idempotency, unique-field enforcement, and the `records:c:<type>` scope check, which is applied per item against that item's own record type. A batch is not a way to write a type your credential could not write one at a time.
    *
    * `atomicity` selects how the batch commits. `best_effort` (the default) writes each item independently: some can succeed while others fail, and each item's own outcome is reported. `all_or_nothing` commits every item in one transaction — if any item fails, no record is created or updated at all, and every item that was itself fine reports `not_committed` while the ones that failed report why. Because the transaction is bounded by the number of underlying storage rows rather than by the number of records, a large `all_or_nothing` batch can be refused as too large to commit atomically even when it is within the item limit; the error says so, and nothing is written when it happens.
    *
@@ -9870,6 +9997,8 @@ var RecordsClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -9926,6 +10055,10 @@ var RecordsClient = class {
           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:
@@ -10074,6 +10207,7 @@ var RecordsClient = class {
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -10113,6 +10247,8 @@ var RecordsClient = class {
       switch (_response.error.statusCode) {
         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:
@@ -10126,7 +10262,7 @@ var RecordsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/records/{id}");
   }
   /**
-   * Partially updates a record using an RFC 7386 JSON Merge Patch. The `payload` object is deep-merged into the existing payload: keys you send overwrite (recursing into nested objects), a key set to null is deleted, and keys you omit are left unchanged — so you can change a single field without re-sending the rest (unlike the full-replacement PUT). Top-level fields (`status`, `folderId`, `userId`, `scopes`) are set when present and left unchanged when omitted; sending a top-level field as null is rejected (clearing a top-level field is not supported in this release — omit it instead). `typeName`, `schemaId`, `externalId`, and `indexMode` are immutable and rejected if present. The merged result is validated against the schema. Pass `expectedVersion` to make the patch conditional (optimistic concurrency, 409 on conflict). Requires the `records:u:<type>` scope.
+   * Partially updates a record using an RFC 7386 JSON Merge Patch. The `payload` object is deep-merged into the existing payload: keys you send overwrite (recursing into nested objects), a key set to null is deleted, and keys you omit are left unchanged — so you can change a single field without re-sending the rest (unlike the full-replacement PUT). Top-level fields (`status`, `folderId`, `userId`, `scopes`) are set when present and left unchanged when omitted; sending a top-level field as null is rejected (clearing a top-level field is not supported — omit it instead). `typeName`, `schemaId`, `externalId`, and `indexMode` are immutable and rejected if present. The merged result is validated against the schema. Pass `expectedVersion` to make the patch conditional (optimistic concurrency, 409 on conflict). Requires the `records:u:<type>` scope.
    *
    * @param {Vectros.PatchRecordRequest} request
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -10555,6 +10691,8 @@ var SchemasClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -10624,6 +10762,10 @@ var SchemasClient = class {
           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:
@@ -10767,7 +10909,7 @@ var SchemasClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/schemas/{id}");
   }
   /**
-   * Permanently deletes a record schema. The request is refused with 409 if records of this type still exist — delete those records first, since every record must reference a live schema. The same applies to documents bound to this schema (for a schema declaring the `document` surface) — delete those documents first. A lineage base (a schema other schemas declare `basedOn`) also cannot be deleted while any such variant still exists — delete the variant schema(s) first. It is likewise refused while any trigger rule fires off this schema — delete those trigger rules first. Requires the `schemas:d` scope.
+   * Permanently deletes a record schema. The request is refused with 409 if records of this type still exist — delete those records first, since every record must reference a live schema. The same applies to documents bound to this schema (for a schema declaring the `document` surface) — delete those documents first. A lineage base (a schema other schemas declare `basedOn`) also cannot be deleted while any such variant still exists — delete the variant schema(s) first. It is likewise refused while any trigger rule fires off this schema — delete those trigger rules first — and, for a schema declaring the `user` or `entity` surface, while any user or entity bound to it still exists. Requires the `schemas:d` scope.
    *
    * @param {Vectros.DeleteSchemaRequest} request
    * @param {SchemasClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -10894,7 +11036,7 @@ var ScriptsClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Runs a script you previously pushed to `POST /v1/scripts`, under your own credential, and returns what it returned. Every write the script makes is buffered and committed as ONE transaction after the script finishes: either all of them land or none do, and the response is sent only after they have committed — so everything in `result` is committed state or the script's own computation over it. On any failure the body is the standard error envelope and nothing the script staged is committed: its rows are written only when the transaction commits, and a document body or a large payload is DECIDED at that point and WRITTEN to storage only after the commit, so an aborted execution leaves nothing behind. The one residual sits after a successful commit, outside this response: if storing a body fails then, the row exists and the body does not until the platform's repair lands — so a `200` guarantees the rows, and a document's text should be read before it is relied on.
+   * Runs a script you previously pushed to `POST /v1/scripts`, under your own credential, and returns what it returned. Every write the script makes is buffered and committed as ONE transaction after the script finishes: either all of them land or none do, and the response is sent only after they have committed — so everything in `result` is committed state or the script's own computation over it. On any failure the body is the standard error envelope and nothing the script staged is committed: its rows are written only when the transaction commits, and a document body or a large payload is DECIDED at that point and WRITTEN to storage only after the commit, so an aborted execution leaves nothing behind. The one residual sits after a successful commit, outside this response: if storing a body fails then, the row exists and the body may not — so a `200` guarantees the rows, and a document's text should be read before it is relied on.
    *
    * **Permission.** Requires the `scripts:x` scope — the permission to *execute* — separate from the `scripts:c` permission to push scripts. Bare `scripts:x` grants every script in the context; `scripts:x:<name>` grants exactly that script name, every version of it. Execution discloses no source, so `scripts:r` is not needed. Inside the script, every read and write is enforced by your credential's data scopes exactly as the equivalent REST call would be — `scripts:x` alone can read and write nothing.
    *
@@ -11508,6 +11650,8 @@ var TriggersClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -11565,6 +11709,10 @@ var TriggersClient = class {
           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:
@@ -11641,6 +11789,7 @@ var TriggersClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -11698,6 +11847,8 @@ var TriggersClient = class {
           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:
@@ -11717,6 +11868,7 @@ var TriggersClient = class {
    * @param {TriggersClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -11756,6 +11908,8 @@ var TriggersClient = class {
       switch (_response.error.statusCode) {
         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:
@@ -12091,7 +12245,7 @@ var BlueprintSchemaSchema = z.object({
   // (`lintNamespacedScopeArrays`) — this `.max(MAX_SCOPE_DIMENSIONS)` is
   // only the shape-level cap, not the grammar check.
   // With a scoped token these must be consistent with the profile's dataScope
-  // (a cross-consistency lint is deferred to the lint slice).
+  // (the lints here check each entry's grammar only, not that consistency).
   userId: z.string().min(1).optional(),
   scopes: z.array(z.string().min(1)).max(MAX_SCOPE_DIMENSIONS).optional(),
   // The id of an existing schema this one is a CUSTOMIZATION of, when a schema
@@ -12457,8 +12611,8 @@ var IdentityDeclSchema = z.object({
   kind: IdentityKindSchema,
   // safeDisplayString: `@vectros-ai/cli`'s `runBootstrapCli` and `blueprint plan` both print
   // this RAW to stdout ("~ <name> (<kind>) — external id '<externalId>'"), immediately before
-  // the "Apply this plan? [y/N]" confirmation gate itself — the highest-severity gap found in
-  // this pass, since it sits at the confirmation prompt's own disclosure text, not merely
+  // the "Apply this plan? [y/N]" confirmation gate itself — the highest-severity place to
+  // close, since it sits at the confirmation prompt's own disclosure text, not merely
   // somewhere upstream of it. `displayName` is wrapped too though not currently
   // rendered in any preview (defense-in-depth, matching this file's practice for its adjacent
   // sibling fields) — it does reach a platform API payload as an entity's `name`.
@@ -12804,7 +12958,7 @@ var SeedCommonShape = {
    * seeds resolve a `reference` against (across surfaces: a record seed may
    * reference a document seed by its externalId, and vice versa).
    * `safeDisplayString`: not currently rendered in a plan-preview line (same as this schema's
-   * `typeName` just above until this pass), but the same "costs nothing to close now" standard
+   * `typeName` just above), but the same "costs nothing to close" standard
    * applies — a short caller-supplied id, not free-form prose, so no YAML block-scalar
    * collision risk like `description`'s.
    */
@@ -13469,10 +13623,10 @@ var BlueprintSchema = z.object({
   /** Stable blueprint id (the `--blueprint <name>` selector + idempotency key). */
   name: safeDisplayString(z.string().min(1)),
   version: safeDisplayString(z.string().min(1)),
-  // NOT safeDisplayString — deliberately, after that wrap broke a real, multi-line-authored
-  // blueprint's `description` in review. `description` is never interpolated into any
+  // NOT safeDisplayString — deliberately: that wrap breaks real, multi-line-authored
+  // blueprint `description`s. `description` is never interpolated into any
   // rendered plan-preview line (`buildPlan`'s header prints
-  // `name`/`version`/`contextId`, never `description` — confirmed by grep, not assumed), so
+  // `name`/`version`/`contextId`, never `description`), so
   // wrapping it protected a sink that does not exist. It also actively broke real content:
   // this is exactly the field authors reach for a YAML folded (`>`) or literal (`|`) block
   // scalar to write, and clip chomping (the YAML default) always leaves exactly one trailing
@@ -13487,9 +13641,8 @@ var BlueprintSchema = z.object({
   /**
    * Human-readable app-context name; defaults to `MCP — <name>` (see {@link contextNameOf})
    * when absent. `safeDisplayString`: `contextNameOf` renders this raw into the FIRST line of
-   * every `buildPlan` summary (the `context '...' (...)` step) — a gap found after the rest
-   * of this file's forgery-character pass had already shipped; same shape as
-   * `name`/`version`/`description` right above it.
+   * every `buildPlan` summary (the `context '...' (...)` step); same shape as
+   * `name`/`version` right above it.
    */
   contextName: safeDisplayString(z.string().min(1)).optional(),
   /**
@@ -13584,9 +13737,8 @@ var BlueprintSchema = z.object({
    */
   identityProjectionClaims: z.array(
     // safeDisplayString: rendered raw into buildPlan's context step (`identity projection:
-    // [...]`) — same rendered-plan-preview shape as `capturedClaims` (its structural pair,
-    // and fixed alongside it originally), missed here in the first pass; same ordering rule
-    // applies (safeDisplayString's own `.refine` before the blank-name `.refine` below,
+    // [...]`) — 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`).
     safeDisplayString(
       z.string().max(MAX_CAPTURED_CLAIM_NAME_LENGTH, {
@@ -13791,7 +13943,7 @@ function deriveSuffix(contextId) {
 var WHOLE_TOKEN_RE = /^\$\{\{\s*([A-Za-z_]\w*)\.([A-Za-z_]\w*)\s*\}\}$/;
 var TOKEN_SCAN_RE = /\$\$\{\{|\$\{\{([\s\S]*?)\}\}|\$\{\{/g;
 var INNER_REF_RE = /^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/;
-var DEFERRED_NAMESPACES = /* @__PURE__ */ new Set(["self", "identities", "under", "member"]);
+var DEFERRED_NAMESPACES = /* @__PURE__ */ new Set(["self", "identities", "under", "member", "input"]);
 var DEFERRED_BARE_TOKENS = /* @__PURE__ */ new Set(["any"]);
 var DEFERRED_NS_ALTERNATION = [...DEFERRED_NAMESPACES].join("|");
 var DEFERRED_INNER_RE = new RegExp(
@@ -16360,14 +16512,14 @@ var COGNITO_ALLOWED_HOSTS = Object.values(PER_ENV).map(
 );
 var BAKED_CLIENT_IDS = {
   staging: "61hjvm25kkjb1eei8t2d3jkcl8",
-  // validated against deployed staging hosted UI (2026-06-05)
+  // deployed staging hosted UI client
   production: "63eipeedjv78q653k45niih46f"
-  // prod SSM /vectros/cli/client-id (validated 2026-06-24)
+  // deployed production hosted UI client
 };
 var MissingCognitoClientIdError = class extends Error {
   constructor(env) {
     super(
-      `No Cognito client id for '${env}'. Set VECTROS_COGNITO_CLIENT_ID (the public DeveloperUserPoolCliClientId from the deploy) \u2014 baking + a discovery endpoint are tracked follow-ups.`
+      `No Cognito client id for '${env}'. Set VECTROS_COGNITO_CLIENT_ID to the public client id of the sign-in app.`
     );
     this.name = "MissingCognitoClientIdError";
   }
@@ -16601,6 +16753,7 @@ async function resolveCognitoToken(env, explicit, deps = { readSession, refreshT
   }
   throw new MissingCredentialError(env);
 }
+var DEFAULT_CONTEXT_ID = "default";
 async function resolveAuthContext(opts) {
   const baseUrl = envToBaseUrl(opts.env, opts.baseUrl ?? process.env.VECTROS_API_BASE_URL);
   const cognitoToken = await resolveCognitoToken(opts.env, opts.token);
@@ -16610,7 +16763,7 @@ async function resolveAuthContext(opts) {
     apiBaseUrl: baseUrl,
     tenant,
     ...opts.context ? { contextId: opts.context } : {}
-  }) : await mintContextToken({ cognitoToken, apiBaseUrl: baseUrl, contextId: opts.context ?? "default", tenant });
+  }) : await mintContextToken({ cognitoToken, apiBaseUrl: baseUrl, contextId: opts.context ?? DEFAULT_CONTEXT_ID, tenant });
   const client = new VectrosClient({ token: bridge.token, environment: baseUrl });
   const identity = await resolveIdentity({ log: opts.log, apiKey: bridge.token, environment: baseUrl });
   return {
@@ -17719,13 +17872,11 @@ function toSdkFields(blueprint, schemaIndex) {
     searchable: f.searchable,
     filterable: f.filterable,
     // Forwarded explicitly, like every sibling here: this mapping is a named-property list, not a
-    // spread, so an unforwarded field is dropped SILENTLY rather than failing — which is what
-    // happened to `validation` before it was added below.
+    // spread, so an unforwarded field is dropped SILENTLY rather than failing.
     inline: f.inline,
     description: f.description,
     enumValues: mapEnumValues(f.enumValues),
-    // Format passthrough — the loader previously DROPPED this (the
-    // "smoking gun" toSdkFields mapped only six props). The platform
+    // Format passthrough. The platform
     // `SchemaRequest.FieldDef.validation` enforces these server-side. The
     // typed blueprint ValidationRules narrows the SDK's free-form Record.
     validation: f.validation,
@@ -17852,7 +18003,7 @@ async function provisionContext(client, input) {
       externalId: blueprint.servicePrincipal.externalId,
       type: "SERVICE",
       // SDK 0.18+ (identity-access rework): UserRequest's free-form attribute bag
-      // was renamed `metadata` → `payload`. Same semantics (arbitrary key/value).
+      // is `payload` (arbitrary key/value).
       payload: { displayName: blueprint.servicePrincipal.displayName }
     }
   });
@@ -18026,7 +18177,7 @@ async function runLoader(client, input) {
       // them), so default to ['record'] when a blueprint omits it. The `as` keeps
       // the literal default assignable to the SDK's enum-array type.
       allowedSurfaces: s.allowedSurfaces ?? ["record"],
-      // Format passthrough — previously dropped by the loader. Ownership mirrors
+      // Format passthrough. Ownership mirrors
       // the SDK `SchemaRequest` shape 1:1: the principal `userId` plus `scopes`
       // (namespaced parent edges `<ns>:<value>`; the flat orgId/clientId fields are gone).
       renderHints: toRenderHintMap(s),
@@ -18877,10 +19028,8 @@ var OsKeychainSecretStore = class {
   }
   /**
    * `present` or `unknown` — **never `absent`**: impossible through `getPassword`,
-   * and held there by POLICY where other evidence exists. (An earlier opening
-   * claimed a "permanent property… not a conservative default someone should
-   * tighten later", which the rest of this very docstring then disowns — the
-   * widening procedure is spelled out below. State the real shape up front.)
+   * and held there by POLICY where other evidence exists (the widening procedure
+   * is spelled out below).
    *
    * Proving absence would require distinguishing "no such entry" from "I could not
    * read it", and that information does not survive the binding: `get_password` is
@@ -18900,7 +19049,7 @@ var OsKeychainSecretStore = class {
    * Linux collection `secret-tool` exits 1 while `getPassword` returns `null`, so
    * the D-Bus layer reports the fault faithfully and `.ok()` is what discards it.
    * A read with real error semantics could therefore make `absent` reachable — and
-   * `find_credentials` now HAS verified semantics on Linux: it throws
+   * `find_credentials` HAS verified semantics on Linux: it throws
    * `org.freedesktop.Secret.Error.IsLocked` against a locked collection (measured;
    * see {@link OsKeychainSecretStore.deleteSecret} for the transcript). That is why
    * `deleteSecret` may confirm a delete while this method may not.
@@ -18910,7 +19059,7 @@ var OsKeychainSecretStore = class {
    * PRUNABLE, which is a behaviour change this CLI has not taken, and Windows'
    * locked-store behaviour is unmeasured (it has no comparable lock state, so there
    * is nothing yet to observe). Verify per-platform before widening; do not infer it
-   * from a signature, which is exactly what produced the bug this replaced.
+   * from a signature.
    */
   async presence(ref) {
     try {
@@ -18941,10 +19090,8 @@ var OsKeychainSecretStore = class {
    *
    * MEASURED, not inferred — and the distinction is the whole point, because
    * {@link OsKeychainSecretStore.presence} rightly forbids inferring a locked
-   * store's behaviour from a `Result` signature ("that inference is exactly what
-   * produced the bug this replaced"), and an earlier version of THIS comment did
-   * precisely that, on the path that authorizes destruction. Being right by luck is
-   * not being right. Against a real locked collection (`node:24-alpine`, non-root,
+   * store's behaviour from a `Result` signature, and doing so on the path that
+   * authorizes destruction would be right only by luck. Against a real locked collection (`node:24-alpine`, non-root,
    * `dbus-run-session` + gnome-keyring, collection locked via
    * `org.freedesktop.Secret.Service.Lock`):
    *
@@ -18959,9 +19106,8 @@ var OsKeychainSecretStore = class {
    * cached handle to it. CI cannot pin this half — it unlocks the collection so the rest of
    * the suite can use it — so the evidence lives here rather than in a test.
    *
-   * The WINDOWS half of the same contract was assumed for seven review rounds and
-   * is now also measured (real Credential Manager, real binding, throwaway service,
-   * 2026-07-17): `findCredentials` enumerates `account` byte-for-byte as stored —
+   * The WINDOWS half of the same contract is also measured (real Credential Manager,
+   * real binding, throwaway service): `findCredentials` enumerates `account` byte-for-byte as stored —
    * case preserved, 48-char refs intact — a confirmed delete empties the
    * enumeration, and `deleteCredential` on a nonexistent ref returns the same
    * meaningless `false` as Linux. So the `.some(c => c.account === ref)` comparison
@@ -19037,11 +19183,11 @@ var CryptoFileSecretStore = class {
   /**
    * The salt is the one file whose loss is UNRECOVERABLE — every `.enc` is scrypt'd
    * against it, so replacing it silently re-keys the store and bricks them all. Two
-   * rules follow, both inherited from siblings that already paid for them:
+   * rules follow:
    *
    *   - A present-but-short salt is treated exactly like a corrupt index
    *     ({@link readKeyring}): throw an actionable error, never silently replace.
-   *     The old code regenerated it, which converts one anomaly into every secret
+   *     Regenerating it would convert one anomaly into every secret
    *     being permanently undecryptable — destruction dressed as repair.
    *   - Creation is temp + hard-link (atomic AND exclusive; below), with an
    *     exclusive-create (`wx`) fallback on no-hardlink filesystems. The link path
@@ -19192,9 +19338,8 @@ var CryptoFileSecretStore = class {
    * EACCES, or the directory not being there AT ALL — answers false, i.e. "we know
    * nothing".
    *
-   * A MISSING `secrets/` reads as "we know nothing", not as an honest empty, and
-   * that is the opposite of what an earlier version concluded. The reasoning that
-   * looked right: nothing has ever been stored, so "no secret here" is true. Why it
+   * A MISSING `secrets/` reads as "we know nothing", not as an honest empty. The
+   * tempting reasoning — nothing has ever been stored, so "no secret here" is true —
    * is wrong: this is only ever consulted about an entry that is IN the index and
    * stamped `crypto-file` — meaning `setSecret` ran, and `setSecret` mkdir's
    * `secrets/` before every write. So for the only entries that reach here, "the
@@ -19205,7 +19350,7 @@ var CryptoFileSecretStore = class {
    * it went. Calling that `absent` invites `prune` to delete the entry and the only
    * record of a keyId whose key is still live.
    *
-   * The fresh-install case this used to serve is not lost: an install with nothing
+   * The fresh-install case needs no special handling: an install with nothing
    * stored has no index entries either, so nothing asks.
    */
   async secretsDirIntact() {
@@ -19322,10 +19467,9 @@ async function withIndexLock(dir, fn, timings = LOCK_OPTS) {
       // Swallowing is the better answer. We cannot un-write what we already wrote;
       // finishing is strictly better than crashing half-done.
       //
-      // What swallowing does NOT buy — and an earlier version of this comment
-      // claimed it did, with a "verified": the library marks a lock released when
-      // it DETECTS a compromise, and then our release below is a no-op that cannot
-      // delete a successor's lock. That detection runs on the mtime-refresh timer,
+      // What swallowing does NOT buy is protection from our own release: the library
+      // marks a lock released when it DETECTS a compromise, after which our release
+      // below would be a no-op that cannot delete a successor's lock. That detection runs on the mtime-refresh timer,
       // every `stale/2` — 2.5s at the shipping 5s — and this file's critical
       // sections are ~1ms, so in practice the holder is gone before the first tick
       // and nothing is ever detected. (The probe that observed the no-op ran at
@@ -19338,10 +19482,8 @@ async function withIndexLock(dir, fn, timings = LOCK_OPTS) {
       // updateKeyring's identity re-check before each commit — which, per its own
       // honesty note, narrows the lost-update window; it does not close it.
       //
-      // RESIDUAL, stated honestly — and the previous version of this comment was
-      // WRONG, so trust the numbers below and not the prose. It claimed reaching a
-      // compromised lock "requires our event loop to freeze past `stale`". It does
-      // not. proper-lockfile's stale-break is `stat` -> judge stale -> `rmdir` ->
+      // RESIDUAL, stated honestly: reaching a compromised lock does NOT require our
+      // event loop to freeze past `stale`. proper-lockfile's stale-break is `stat` -> judge stale -> `rmdir` ->
       // `mkdir`, and it never re-checks that the directory it removes is the one it
       // judged: two waiters can both condemn one crash remnant, and the second's
       // already-decided rmdir destroys the first's FRESH lock. Nothing freezes.
@@ -19358,10 +19500,10 @@ async function withIndexLock(dir, fn, timings = LOCK_OPTS) {
       // round-trip. Rare, not impossible — and inherent to mtime-based locking of
       // this shape.
       //
-      // Accepted KNOWINGLY. The hand-rolled lock this replaced serialised the break
-      // behind a second mutex — the right idea — and that mutex then age-broke a LIVE
-      // breaker at 10s with no liveness check: `maxOccupancy = 2`, measured with no
-      // injection at all, plus 0.57% of contended acquires dying on Windows EPERM.
+      // Accepted KNOWINGLY. A hand-rolled lock that serialised the break
+      // behind a second mutex — the right idea — hits a defect there: that mutex age-breaks a LIVE
+      // breaker at 10s with no liveness check (`maxOccupancy = 2`, measured with no
+      // injection at all), plus 0.57% of contended acquires dying on Windows EPERM.
       // Trading a measured, reachable defect for one that needs injected lag to
       // observe is the right trade; pretending it is zero is not. If it ever needs
       // closing the fix is upstream (re-stat under the removal), NOT another
@@ -19491,8 +19633,8 @@ var Keyring = class _Keyring {
   /**
    * Where new secrets go, or undefined if the selected store isn't actually here.
    *
-   * That sounds impossible — the file store is always constructed — and an earlier
-   * version said exactly that and cast the `undefined` away. It was wrong:
+   * That sounds impossible — the file store is always constructed — so it is tempting
+   * to cast the `undefined` away. That would be wrong:
    * `new Keyring({ selection: { kind: 'os-keychain' } })` with no `keychainStore`
    * names a store that was never supplied, and a cast does not conjure one. Return
    * the honest type and let {@link storeSecretSomewhere} handle it, rather than
@@ -19670,7 +19812,7 @@ The key itself WAS created server-side and is live \u2014 its id is ${entry.keyI
    * {@link storeSecretSomewhere} throws — i.e. only when no store on this machine
    * will accept a write at all, which is the failure worth stopping for.
    *
-   * Still NOT a proof that {@link add} will succeed, and the gap is now only the
+   * Still NOT a proof that {@link add} will succeed, and the remaining gap is only the
    * genuinely transient: a lock another process holds for longer than the retry
    * budget, or a CAS race, either of which a retry actually fixes. What it DOES
    * cover is every deterministic refusal — no writable secret store, and an index
@@ -19704,11 +19846,11 @@ The key itself WAS created server-side and is live \u2014 its id is ${entry.keyI
    * delete, and no other store PROVED it still holds a copy.
    *
    * That is deliberately WEAKER than "proved gone everywhere", and saying the
-   * stronger thing (an earlier version promised "PROVED gone") hid a real residual:
+   * stronger thing ("PROVED gone") would hide a real residual:
    * a non-home store vetoes only on `present`, and a LOCKED keychain answers
    * `unknown` — so on the one state this store's model is built around, a stale copy behind a
    * locked non-home store passes unvetoed. That is the chosen trade, not an
-   * oversight: the alternative (veto on doubt) shipped, and made an unrelated
+   * oversight: the alternative (veto on doubt) would let an unrelated
    * locked keychain block removal of file-store entries forever, with advice to
    * unlock a store that never held the secret.
    *
@@ -19769,7 +19911,7 @@ The key itself WAS created server-side and is live \u2014 its id is ${entry.keyI
    * freshly minted `keyId` on every path (`issueOrRotateKey` either creates a new key
    * or revokes-and-recreates, and both mint a new id), so `prior.secretRef !==
    * stamped.secretRef` always holds and `add` always takes the `forgetEverywhere`
-   * branch. Two reviewers read this as dead code. It is not — it is UNEXERCISED, and
+   * branch. That does not make this dead code — it is UNEXERCISED by `join`, and
    * the distinction matters:
    *
    *   - `add` is public and takes the entry as an argument, so "the caller supplies a
@@ -19836,10 +19978,10 @@ The key itself WAS created server-side and is live \u2014 its id is ${entry.keyI
    * `keyId`, so dropping it while the `ssk_*` survives leaves a live, unrevokable
    * credential on the machine.
    *
-   * The gate is the DELETE'S RESULT, not whether the store looked reachable. An
-   * earlier version gated on reachability and shipped the bug anyway, because a
+   * The gate is the DELETE'S RESULT, not whether the store looked reachable. A
+   * reachability gate would not work, because a
    * LOCKED keychain is perfectly reachable — it constructs, it answers, it just
-   * won't do anything. The guard never fired, the delete quietly failed, the row was
+   * won't do anything. The guard would never fire, the delete would quietly fail, the row would be
    * dropped. Reachability is a proxy; "is it gone?" is the question.
    *
    * The secret is destroyed BEFORE the index row, the opposite of {@link add}, and
@@ -19854,10 +19996,8 @@ The key itself WAS created server-side and is live \u2014 its id is ${entry.keyI
    * for as long as a user takes to type would time out every other vectros process,
    * including an MCP server trying to start. The lock buys nothing here anyway —
    * `add` writes its secret outside the lock too, so the two secret-writes were
-   * never serialised by it. So: the INITIAL read is unlocked (an earlier version
-   * claimed it was locked; the correction then overshot to "nothing here reads
-   * under a lock" — false too: the commit-time re-check below IS a read inside
-   * `updateKeyring`'s lock). Delete outside the lock, then commit under it,
+   * never serialised by it. So: the INITIAL read is unlocked (the commit-time
+   * re-check below, by contrast, IS a read inside `updateKeyring`'s lock). Delete outside the lock, then commit under it,
    * re-checking that the entry is still the one the unlocked read saw. That locked
    * re-check is what stands in for having read under the lock to begin with.
    */
@@ -20007,18 +20147,17 @@ The key itself WAS created server-side and is live \u2014 its id is ${entry.keyI
    * already HAS the secret, so every failure here is silent and leaves the machine
    * as it found it, for the next read to retry.
    *
-   * "As it found it" is a promise about BOTH stores, and that is the part an earlier
-   * version got wrong. It said failure "simply leaves the secret where it was" while
-   * three abort paths returned after `setSecret` had already landed a SECOND copy in
+   * "As it found it" is a promise about BOTH stores. Saying failure "simply leaves the
+   * secret where it was" would be false for any abort path that returned after
+   * `setSecret` had already landed a SECOND copy in
    * the target and left it there — a copy of a live `ssk_*` that no index row names,
    * i.e. the exact strand `forgetEverywhere` exists to prevent, produced by the
    * function that migrates.
    *
    * So the target copy is treated as UNCOMMITTED until the migration actually lands,
    * and `finally` clears it on every other route out. That is structural rather than
-   * remembered: two of the three leaking paths already had a hand-written cleanup and
-   * the other two did not, which is precisely the shape of bug that keeps costing this
-   * file a review round. The flag cannot be forgotten on a path added later.
+   * remembered: a hand-written cleanup per abort path is precisely the shape that gets
+   * forgotten on one of them. The flag cannot be forgotten on a path added later.
    *
    * The ordering is the rest of the design, and each step guards a different disaster:
    * write the new copy; read it back (a write that silently didn't land would
@@ -22907,7 +23046,11 @@ async function runWhoami(options, deps = {}) {
       self2 = null;
     }
     if (options.json) {
-      const out = self2 ? { ...identity, userId: self2.userId, userPrincipalId: self2.principalId } : identity;
+      const out = {
+        ...identity,
+        tenantType: auth.tenant,
+        ...self2 ? { userId: self2.userId, userPrincipalId: self2.principalId } : {}
+      };
       process.stdout.write(`${formatJson(out)}
 `);
       return 0;
@@ -22916,6 +23059,7 @@ async function runWhoami(options, deps = {}) {
     process.stdout.write(
       "\n" + formatKeyValues([
         ["tenant", identity.tenantId],
+        ["tenant type", auth.tenant],
         ["environment", identity.environment],
         ["principal", identity.principalType],
         ["principal id", identity.principalKeyId],
@@ -23724,6 +23868,12 @@ async function runAccessRevoke(opts, deps = {}) {
     }
   });
 }
+function searchedContextNotice(principal, rows, tenant) {
+  if (rows.some((r) => r.contextId !== void 0 && r.contextId !== DEFAULT_CONTEXT_ID)) return void 0;
+  const tenantFlag = tenant === "test" ? " --tenant test" : "";
+  return `  \u2139 Listed with a token pinned to context '${DEFAULT_CONTEXT_ID}' (${tenant} tenant). Depending on the caller, the platform may not look beyond that context, so a grant in another context may be missing; an empty result means none in '${DEFAULT_CONTEXT_ID}'. Check a context with: vectros access get --principal ${principal} --context <c>${tenantFlag}
+`;
+}
 async function runAccessList(opts, deps = {}) {
   if (Boolean(opts.context) === Boolean(opts.principal)) {
     process.stderr.write("  \u2716 Provide exactly one of --context <c> or --principal <p>.\n");
@@ -23747,9 +23897,11 @@ async function runAccessList(opts, deps = {}) {
       ) : await drainPages(
         (startFrom) => client.auth.listProfilesForPrincipal({ principalId: principal, startFrom, limit: PAGE_LIMIT })
       );
+      const notice = opts.principal ? searchedContextNotice(opts.principal, rows, auth.tenant) : void 0;
       if (opts.json) {
         process.stdout.write(`${formatJson(rows)}
 `);
+        if (notice) process.stderr.write(notice);
         return 0;
       }
       process.stdout.write(
@@ -23760,6 +23912,7 @@ async function runAccessList(opts, deps = {}) {
           { header: "status", get: (r) => r.status }
         ]) + "\n"
       );
+      if (notice) process.stderr.write(notice);
       return 0;
     } catch (err) {
       process.stderr.write(`  \u2716 access list failed: ${formatError(err)}
@@ -26941,9 +27094,9 @@ function emitJoined(opts) {
 
 // src/build-info.ts
 var BUILD_INFO = {
-  cli: true ? "0.25.0" : "dev",
-  sdk: true ? "0.47.0" : "dev",
-  blueprints: true ? "0.20.2" : "dev"
+  cli: true ? "0.26.0" : "dev",
+  sdk: true ? "0.48.0" : "dev",
+  blueprints: true ? "0.20.3" : "dev"
 };
 function formatBuildInfo() {
   return `vectros ${BUILD_INFO.cli} (sdk ${BUILD_INFO.sdk}, blueprints ${BUILD_INFO.blueprints})`;
@@ -27002,9 +27155,11 @@ function buildProgram(deps = {}) {
   program.command("logout").description("Clear the stored login session.").action(async () => {
     process.exitCode = await runLogout({ env: "production", json: false });
   });
-  const whoami = program.command("whoami").description("Show the authenticated session (tenant, env, principal).");
+  const whoami = program.command("whoami").description("Show the authenticated session (tenant, env, principal).").option("--tenant <tenant>", "tenant to show: 'test' or 'live' (default live)");
   addCommonAuthOptions(whoami).action(async (flags) => {
-    process.exitCode = await runWhoami(toCommonOptions(flags), deps);
+    const tenant = parseTenantFlag(flags.tenant);
+    if (tenant === TENANT_FLAG_INVALID) return;
+    process.exitCode = await runWhoami({ ...toCommonOptions(flags), tenant }, deps);
   });
   const blueprintTest = program.command("blueprint-test").description("Apply a blueprint to a live env, assert it provisioned a working credential, then tear it down.").argument("<file>", "blueprint file path (./my.yaml) or a bundled blueprint name").option("--keep", "leave the provisioned graph in place (skip teardown) for inspection").option("--tenant <tenant>", "target tenant for the run: 'test' or 'live' (default live)");
   addCommonAuthOptions(blueprintTest).action(