@gravity-rail/cli 0.3.0 → 0.4.0

package/dist/lib.js

@@ -1,6 +1,8 @@
 import {
   AGUIClient,
   CredentialsManager,
+  __export,
+  __reExport,
   clearScreen,
   formatTimestamp,
   getEnvironmentConfig,
@@ -11,7 +13,7 @@ import {
   printTable,
   refreshAccessToken,
   selectFromList
-} from "./chunk-OIFV7TAT.js";
+} from "./chunk-C6D4FO6A.js";
 
 // src/lib/errors.ts
 var CLIError = class extends Error {
@@ -264,8 +266,1460 @@ function findDef(defs, arg) {
   return void 0;
 }
 
-// src/lib/context.ts
+// ../client/dist/index.mjs
+var dist_exports = {};
+__export(dist_exports, {
+  AdminApi: () => AdminApi,
+  ApiClient: () => ApiClient,
+  bindAdminMethods: () => bindAdminMethods
+});
+__reExport(dist_exports, internal_star);
+import * as internal_star from "@gravity-rail/sdk/internal";
+import { BaseApiClient } from "@gravity-rail/sdk/internal";
 import { GravityRailClient } from "@gravity-rail/sdk";
+var AdminApi = class extends BaseApiClient {
+  // Admin Accounts API
+  async getAccounts(options) {
+    const params = new URLSearchParams();
+    if (options.search) params.append("search", options.search);
+    if (options.createdAfter) params.append("created_after", options.createdAfter);
+    if (options.createdBefore) params.append("created_before", options.createdBefore);
+    if (options.sortBy) params.append("sortBy", options.sortBy);
+    if (options.sortOrder) params.append("sortOrder", options.sortOrder);
+    if (options.page) params.append("page", options.page.toString());
+    if (options.pageSize) params.append("pageSize", options.pageSize.toString());
+    if (options.isActive !== void 0) params.append("isActive", options.isActive.toString());
+    if (options.organizationId !== void 0)
+      params.append("organizationId", options.organizationId.toString());
+    if (options.pendingDeletion !== void 0)
+      params.append("pendingDeletion", options.pendingDeletion.toString());
+    return this.fetch(`admin/accounts?${params.toString()}`);
+  }
+  async getAccountDetails(id) {
+    return this.fetch(`admin/accounts/${id}`);
+  }
+  async getAccountByUuid(uuid) {
+    return this.fetch(`admin/accounts/${uuid}`);
+  }
+  async getAccountMemberships(accountId) {
+    return this.fetch(`admin/accounts/${accountId}/memberships`);
+  }
+  async getAccountOrgMemberships(accountId) {
+    return this.fetch(`admin/accounts/${accountId}/org-memberships`);
+  }
+  async createAccountOrgMembership(accountId, organizationId, role = "member") {
+    return this.fetch(`admin/accounts/${accountId}/org-memberships`, {
+      method: "POST",
+      body: JSON.stringify({ organizationId, role })
+    });
+  }
+  async deleteAccountOrgMembership(accountId, organizationId) {
+    return this.fetch(`admin/accounts/${accountId}/org-memberships/${organizationId}`, {
+      method: "DELETE"
+    });
+  }
+  async getAccountMembership(accountId, workspaceId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/memberships/${workspaceId}`
+    );
+  }
+  async updateAccountMembership(accountId, workspaceId, updates) {
+    return this.fetch(
+      `admin/accounts/${accountId}/memberships/${workspaceId}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(updates)
+      }
+    );
+  }
+  async createAccountMembership(accountId, workspaceId, data) {
+    return this.fetch(
+      `admin/accounts/${accountId}/memberships/${workspaceId}`,
+      {
+        method: "POST",
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  async deleteAccountMembership(accountId, workspaceId) {
+    return this.fetch(`admin/accounts/${accountId}/memberships/${workspaceId}`, {
+      method: "DELETE"
+    });
+  }
+  async updateAccountAsAdmin(id, updates) {
+    return this.fetch(`admin/accounts/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(updates)
+    });
+  }
+  async createAccountAsAdmin(data) {
+    return this.fetch("admin/accounts", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteAccountAsAdmin(id) {
+    return this.fetch(`admin/accounts/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // GDPR Data Subject Rights (superuser only)
+  async exportAccountData(accountId) {
+    return this.fetch(`admin/data-rights/${accountId}/export`, {
+      method: "POST"
+    });
+  }
+  async requestAccountDeletion(accountId) {
+    return this.fetch(`admin/data-rights/${accountId}/delete`, {
+      method: "POST"
+    });
+  }
+  async cancelAccountDeletion(accountId) {
+    return this.fetch(`admin/data-rights/${accountId}/cancel-delete`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Look up an account by email or phone. Returns verification status.
+   * Used to check if a verified account exists before creating a new one.
+   */
+  async lookupAccount(options) {
+    const params = new URLSearchParams();
+    if (options.email) params.append("email", options.email);
+    if (options.phone) params.append("phone", options.phone);
+    return this.fetch(`admin/accounts/lookup?${params.toString()}`);
+  }
+  // Admin Organizations API
+  async getOrganizations(options) {
+    const params = new URLSearchParams();
+    if (options?.search) params.append("search", options.search);
+    if (options?.page) params.append("page", options.page.toString());
+    if (options?.pageSize) params.append("pageSize", options.pageSize.toString());
+    if (options?.noSubscription) params.append("no_subscription", "true");
+    if (options?.sortBy) params.append("sortBy", options.sortBy);
+    if (options?.sortOrder) params.append("sortOrder", options.sortOrder);
+    return this.fetch(
+      `admin/organizations?${params.toString()}`
+    );
+  }
+  /**
+   * Get organization by ID or UUID.
+   * Returns different response based on user's role:
+   * - Admins/Owners: AdminOrganization with full details
+   * - Members: MemberOrgView with basic info and workspace list
+   *
+   * Use `viewType` field to determine the response type:
+   * - 'admin': AdminOrganization
+   * - 'member': MemberOrgView
+   */
+  async getOrganization(idOrUuid) {
+    return this.fetch(`o/${idOrUuid}`);
+  }
+  /**
+   * Get organization by numeric ID via admin endpoint.
+   * Does NOT require organization membership — superuser-only.
+   */
+  async getOrganizationAsAdmin(id) {
+    return this.fetch(`admin/organizations/${id}`);
+  }
+  async getOrganizationMembersAsAdmin(organizationId, options) {
+    const params = new URLSearchParams();
+    if (options?.search) params.append("search", options.search);
+    if (options?.role) params.append("role", options.role);
+    if (options?.page) params.append("page", options.page.toString());
+    if (options?.pageSize) params.append("pageSize", options.pageSize.toString());
+    const qs = params.toString();
+    return this.fetch(
+      `admin/organizations/${organizationId}/members${qs ? `?${qs}` : ""}`
+    );
+  }
+  async createOrganization(data) {
+    return this.fetch("admin/organizations", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateOrganization(id, data) {
+    return this.fetch(`admin/organizations/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteOrganization(id) {
+    return this.fetch(`admin/organizations/${id}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Join an organization with a specified role (superuser only).
+   * Creates or updates membership in the target org.
+   * @param orgUuid - Organization UUID or numeric ID as string
+   */
+  async joinOrganization(orgUuid, role = "owner") {
+    return this.fetch(`admin/organizations/${orgUuid}/join`, {
+      method: "POST",
+      body: JSON.stringify({ role })
+    });
+  }
+  /**
+   * Leave an organization (superuser only).
+   * @param orgUuid - Organization UUID or numeric ID as string
+   */
+  async leaveOrganization(orgUuid) {
+    return this.fetch(`admin/organizations/${orgUuid}/join`, {
+      method: "DELETE"
+    });
+  }
+  async generateLogoUploadUrl(organizationUuid, data) {
+    return this.fetch(`o/${organizationUuid}/logo-upload-url`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  // Organization Members API - moved to OrgApi at /api/v2/o/{org_uuid}/members
+  // See packages/client/src/api/org.ts
+  // Organization Invitations API - moved to OrgApi at /api/v2/o/{org_uuid}/invitations
+  // See packages/client/src/api/org.ts
+  // Admin Products API
+  async importProducts(workspaceId) {
+    return this.fetch("admin/import-products", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId })
+    });
+  }
+  // ===== Product CRUD =====
+  async createProductAsAdmin(product) {
+    return this.fetch("admin/products", {
+      method: "POST",
+      body: JSON.stringify(product)
+    });
+  }
+  async getProductsAsAdmin(workspaceUuid, productTypes) {
+    const params = new URLSearchParams();
+    if (workspaceUuid) {
+      params.append("workspace_uuid", workspaceUuid);
+    }
+    if (productTypes && productTypes.length > 0) {
+      productTypes.forEach((type) => params.append("product_types", type));
+    }
+    const queryString = params.toString();
+    return this.fetch(`admin/products${queryString ? `?${queryString}` : ""}`);
+  }
+  async getProductAsAdmin(productId) {
+    return this.fetch(`admin/products/${productId}`);
+  }
+  async updateProductAsAdmin(product_id, product) {
+    return this.fetch(`admin/products/${product_id}`, {
+      method: "PUT",
+      body: JSON.stringify(product)
+    });
+  }
+  async deleteProductAsAdmin(productId) {
+    return this.fetch(`admin/products/${productId}`, {
+      method: "DELETE"
+    });
+  }
+  // Admin Workspace API
+  async getWorkspacesAsAdmin(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page !== void 0) params.append("page", options.page.toString());
+    if (options.pageSize !== void 0) params.append("pageSize", options.pageSize.toString());
+    if (options.sortBy) params.append("sortBy", options.sortBy);
+    if (options.sortOrder) params.append("sortOrder", options.sortOrder);
+    if (options.search) params.append("search", options.search);
+    if (options.isReseller !== void 0)
+      params.append("isReseller", options.isReseller.toString());
+    if (options.organizationId !== void 0)
+      params.append("organizationId", options.organizationId.toString());
+    if (options.noActiveSubscription) params.append("noActiveSubscription", "true");
+    return this.fetch(`admin/workspaces?${params.toString()}`);
+  }
+  async getWorkspaceAsAdmin(wid) {
+    return this.fetch(`admin/workspaces/${wid}`);
+  }
+  async getWorkspaceByNumericIdAsAdmin(workspace_id) {
+    return this.fetch(`admin/workspaces/id/${workspace_id}`);
+  }
+  async createWorkspaceAsAdmin(ws) {
+    return this.fetch("admin/workspaces", {
+      method: "POST",
+      body: JSON.stringify(ws)
+    });
+  }
+  async updateWorkspaceAsAdmin(wid, ws) {
+    return this.fetch(`admin/workspaces/${wid}`, {
+      method: "PUT",
+      body: JSON.stringify(ws)
+    });
+  }
+  async deleteWorkspaceAsAdmin(wid) {
+    return this.fetch(`admin/workspaces/${wid}`, {
+      method: "DELETE"
+    });
+  }
+  async createSchemaAsAdmin(wid) {
+    return this.fetch(`admin/workspaces/${wid}/provision/create`, {
+      method: "POST"
+    });
+  }
+  async migrateSchemaAsAdmin(wid) {
+    return this.fetch(`admin/workspaces/${wid}/provision/migrate`, {
+      method: "POST"
+    });
+  }
+  async provisionWorkspaceAsAdmin(wid) {
+    return this.fetch(`admin/workspaces/${wid}/provision`, {
+      method: "POST"
+    });
+  }
+  async refreshProvisionStatusAsAdmin(wid) {
+    return this.fetch(`admin/workspaces/${wid}/provision/refresh`, {
+      method: "POST"
+    });
+  }
+  async enableMaintenanceMode(wid) {
+    return this.fetch(`admin/workspaces/${wid}/maintenance`, {
+      method: "PUT"
+    });
+  }
+  async disableMaintenanceMode(wid) {
+    return this.fetch(`admin/workspaces/${wid}/maintenance`, {
+      method: "DELETE"
+    });
+  }
+  // ===== Workspace Health Check =====
+  async getWorkspaceHealth(workspaceUuid) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/health`);
+  }
+  async provisionPlanFeatures(workspaceUuid, request) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/provision-plan`, {
+      method: "POST",
+      body: JSON.stringify(request || {})
+    });
+  }
+  // ===== Workflow Access Validation =====
+  async validateWorkflowAccessAsAdmin(workspaceUuid) {
+    const params = new URLSearchParams();
+    if (workspaceUuid) params.append("workspace_uuid", workspaceUuid);
+    const qs = params.toString();
+    return this.fetch(
+      `admin/workspaces/validate-workflow-access${qs ? `?${qs}` : ""}`
+    );
+  }
+  async mergeMembers(wid, request) {
+    return this.fetch(`admin/workspaces/${wid}/merge-members`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getAdminWorkspaceMember(wid) {
+    return this.fetch(`admin/workspaces/${wid}/me`, {
+      method: "GET"
+    });
+  }
+  async createAdminWorkspaceMember(wid, data) {
+    return this.fetch(`admin/workspaces/${wid}/me`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateAdminWorkspaceMember(wid, data) {
+    return this.fetch(`admin/workspaces/${wid}/me`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async getAdminWorkspaceMemberRoles(wid) {
+    return this.fetch(`admin/workspaces/${wid}/member-roles`);
+  }
+  async getUnmappedPhoneNumbers() {
+    return this.fetch(`admin/phone-numbers/unmapped`);
+  }
+  async getWorkspaceUnmappedPhoneNumbers(workspaceId) {
+    return this.fetch(
+      `admin/phone-numbers/workspace/${workspaceId}/unmapped`
+    );
+  }
+  async getWorkspacePhoneNumbersAsAdmin(workspaceId) {
+    return this.fetch(`admin/workspace/${workspaceId}/phone-numbers`);
+  }
+  // Phone Numbers API (Provider phone numbers from Twilio, AWS, etc.)
+  async getProviderPhoneNumbers(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", options.page.toString());
+    if (options.pageSize) params.append("pageSize", options.pageSize.toString());
+    if (options.search) params.append("search", options.search);
+    if (options.isAssigned !== void 0)
+      params.append("is_assigned", String(options.isAssigned));
+    if (options.provider) params.append("provider", options.provider);
+    if (options.organizationId !== void 0)
+      params.append("organizationId", options.organizationId.toString());
+    if (options.sortBy) params.append("sortBy", options.sortBy);
+    if (options.sortOrder) params.append("sortOrder", options.sortOrder);
+    return this.fetch(
+      `admin/phone-numbers${params.toString() ? `?${params.toString()}` : ""}`
+    );
+  }
+  async getProviderPhoneNumber(id) {
+    return this.fetch(`admin/phone-numbers/${id}`);
+  }
+  async updateProviderPhoneNumber(id, data) {
+    return this.fetch(`admin/phone-numbers/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async mapMainAccountPhone(data) {
+    return this.fetch(`admin/phone-numbers/map-from-main-account`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async unmapPhoneNumber(data) {
+    return this.fetch(`admin/phone-numbers/unmap`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async searchAvailablePhoneNumbersAsAdmin(data) {
+    return this.fetch(`admin/phone-numbers/search`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async purchasePhoneNumberAsAdmin(data) {
+    return this.fetch(`admin/phone-numbers/purchase`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getOrgA2PStatusAsAdmin(organizationId) {
+    return this.fetch(`admin/organizations/${organizationId}/a2p-status`);
+  }
+  async resetOrgA2PStatusAsAdmin(organizationId) {
+    return this.fetch(`admin/organizations/${organizationId}/a2p-status`, {
+      method: "DELETE"
+    });
+  }
+  // Site Mappings API
+  async getSiteMappings(options) {
+    const queryParams = new URLSearchParams();
+    if (options?.search) queryParams.append("search", options.search);
+    if (options?.page) queryParams.append("page", options.page.toString());
+    if (options?.pageSize) queryParams.append("pageSize", options.pageSize.toString());
+    const queryString = queryParams.toString();
+    const url = `admin/site-mappings${queryString ? `?${queryString}` : ""}`;
+    return this.fetch(url);
+  }
+  async getSiteMapping(siteId) {
+    return this.fetch(`admin/site-mappings/${siteId}`);
+  }
+  async updateSiteMapping(siteId, data) {
+    return this.fetch(`admin/site-mappings/${siteId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateSiteMappingWorkspace(siteId, workspaceId) {
+    return this.updateSiteMapping(siteId, {
+      workspaceId,
+      siteUuid: ""
+      // These fields are required by the type but will be ignored on the server
+    });
+  }
+  async adminDeleteSiteMapping(siteId) {
+    return this.fetch(`admin/site-mappings/${siteId}`, {
+      method: "DELETE"
+    });
+  }
+  async createSiteMapping(mapping) {
+    return this.fetch(`admin/site-mappings`, {
+      method: "POST",
+      body: JSON.stringify(mapping)
+    });
+  }
+  // Keep for backward compatibility
+  async createOrUpdateSiteMapping(wid, mapping) {
+    return this.fetch(`admin/workspaces/${wid}/site-mappings`, {
+      method: "POST",
+      body: JSON.stringify(mapping)
+    });
+  }
+  async deleteSiteMapping(wid, siteUuid) {
+    return this.fetch(`admin/workspaces/${wid}/site-mappings/${siteUuid}`, {
+      method: "DELETE"
+    });
+  }
+  // Admin Inbox Mappings API
+  async getInboxMappings(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", options.page.toString());
+    if (options.pageSize) params.append("pageSize", options.pageSize.toString());
+    if (options.search) params.append("search", options.search);
+    if (options.workspaceId) params.append("workspaceId", options.workspaceId.toString());
+    return this.fetch(
+      `admin/inbox-mappings${params.toString() ? `?${params.toString()}` : ""}`
+    );
+  }
+  async getInboxMapping(id) {
+    return this.fetch(`admin/inbox-mappings/${id}`);
+  }
+  async updateInboxMapping(id, workspaceId) {
+    return this.fetch(`admin/inbox-mappings/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ workspaceId })
+    });
+  }
+  async deleteAdminInboxMapping(id) {
+    return this.fetch(`admin/inbox-mappings/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Evaluation API
+  async generateChatSummaries(options) {
+    return this.fetch("admin/generate-summaries", {
+      method: "POST",
+      body: JSON.stringify({
+        after_date: options.afterDate ? options.afterDate.toISOString().split("T")[0] + "T" + options.afterDate.toTimeString().split(" ")[0] : void 0,
+        only_without_summaries: options.onlyWithoutSummaries ?? true
+      })
+    });
+  }
+  async executeQuery(options) {
+    return this.fetch("admin/execute-query", {
+      method: "POST",
+      body: JSON.stringify({
+        query: options.query,
+        workspace_uuid: options.workspaceUuid
+      })
+    });
+  }
+  // Admin Themes API
+  async listAllThemes() {
+    return this.fetch("admin/themes/list");
+  }
+  // One-off Redis cadence-key migration (periodiq_* → routine_*). See
+  // lib/routes/admin/admin_routine_cadence_api.py for context.
+  async migrateRoutineCadenceKeys(options) {
+    return this.fetch("admin/redis/routine-cadence/migrate", {
+      method: "POST",
+      body: JSON.stringify({
+        dryRun: options.dryRun ?? true,
+        deleteLegacy: options.deleteLegacy ?? false
+      })
+    });
+  }
+  // Missing Memberships API
+  async getMissingMemberships(workspaceId) {
+    return this.fetch(
+      `admin/workspaces/${workspaceId}/missing-memberships`
+    );
+  }
+  async linkMissingMembership(workspaceId, memberId, accountId) {
+    return this.fetch(
+      `admin/workspaces/${workspaceId}/link-membership?member_id=${memberId}&account_id=${accountId}`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  // Bulk Phone Classification API
+  async startBulkPhoneClassification(workspaceUuid, includeUnknown = false) {
+    const params = new URLSearchParams();
+    params.append("include_unknown", includeUnknown.toString());
+    return this.fetch(`admin/workspaces/${workspaceUuid}/bulk-classify-phones?${params.toString()}`, {
+      method: "POST"
+    });
+  }
+  // Bulk TOS Acceptance API
+  async startBulkTOSAcceptance(workspaceUuid) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/bulk-accept-tos`, {
+      method: "POST"
+    });
+  }
+  // Token Usage Backfill API
+  async startTokenUsageBackfill(workspaceUuid) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/backfill-token-usage`, {
+      method: "POST"
+    });
+  }
+  // ===== Admin Chat Endpoints =====
+  async listWorkspaceChats(workspaceUuid, options) {
+    const params = new URLSearchParams();
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.pageSize) params.set("pageSize", String(options.pageSize));
+    if (options?.search) params.set("search", options.search);
+    if (options?.chatType) params.set("chatType", options.chatType);
+    if (options?.channel) params.set("channel", options.channel);
+    if (options?.archived !== void 0) params.set("archived", String(options.archived));
+    const qs = params.toString();
+    return this.fetch(
+      `admin/workspaces/${workspaceUuid}/chats${qs ? `?${qs}` : ""}`
+    );
+  }
+  async getWorkspaceChat(workspaceUuid, chatId, options) {
+    const params = new URLSearchParams();
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.pageSize) params.set("pageSize", String(options.pageSize));
+    const qs = params.toString();
+    return this.fetch(
+      `admin/workspaces/${workspaceUuid}/chats/${chatId}${qs ? `?${qs}` : ""}`
+    );
+  }
+  // Update chat message content
+  async updateChatMessage(workspaceUuid, chatId, messageId, content) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/chats/${chatId}/messages/${messageId}`, {
+      method: "POST",
+      body: JSON.stringify({ content })
+    });
+  }
+  async rateWorkspaceChatMessage(workspaceUuid, chatId, messageId, rating, comment) {
+    return this.fetch(
+      `admin/workspaces/${workspaceUuid}/chats/${chatId}/messages/${messageId}/rate`,
+      {
+        method: "POST",
+        body: JSON.stringify({ rating, comment })
+      }
+    );
+  }
+  // ===== Stripe Customer Management =====
+  async getStripeCustomer(accountId) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/customer`);
+  }
+  async createStripeCustomer(accountId, data) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/customer`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateStripeCustomer(accountId, data) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/customer`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  // ===== Customer Management =====
+  async createCustomerFromAccount(accountId) {
+    return this.fetch(`admin/accounts/${accountId}/customer`, {
+      method: "POST"
+    });
+  }
+  async getCustomers(options) {
+    const params = new URLSearchParams();
+    if (options?.search) params.set("search", options.search);
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.pageSize) params.set("page_size", String(options.pageSize));
+    const qs = params.toString();
+    return this.fetch(`admin/customers${qs ? `?${qs}` : ""}`);
+  }
+  async getCustomer(customerId) {
+    return this.fetch(`admin/customers/${customerId}`);
+  }
+  async createCustomer(data) {
+    return this.fetch("admin/customers", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateCustomer(customerId, data) {
+    return this.fetch(`admin/customers/${customerId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async syncCustomerToStripe(customerId) {
+    return this.fetch(`admin/customers/${customerId}/stripe/sync`, {
+      method: "POST"
+    });
+  }
+  async getCustomerAccounts(customerId) {
+    return this.fetch(`admin/customers/${customerId}/accounts`);
+  }
+  async linkCustomerToAccount(customerId, accountId, role) {
+    return this.fetch(`admin/customers/${customerId}/accounts`, {
+      method: "POST",
+      body: JSON.stringify({ accountId, role })
+    });
+  }
+  async unlinkCustomerFromAccount(customerId, accountId) {
+    await this.fetch(`admin/customers/${customerId}/accounts/${accountId}`, {
+      method: "DELETE"
+    });
+  }
+  // ===== Stripe Subscription Management =====
+  async getStripeSubscriptions(accountId) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/subscriptions`);
+  }
+  async createStripeSubscription(customerId, data) {
+    return this.fetch(`admin/customers/${customerId}/stripe/subscriptions`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async createDirectSubscription(customerId, data) {
+    return this.fetch(`admin/customers/${customerId}/direct/subscriptions`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateStripeSubscription(accountId, subscriptionId, data) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/subscriptions/${subscriptionId}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  async cancelStripeSubscription(accountId, subscriptionId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/subscriptions/${subscriptionId}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async provisionWorkspaceForSubscription(accountId, subscriptionId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/subscriptions/${subscriptionId}/provision`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  async associateWorkspaceWithSubscription(accountId, subscriptionId, workspaceId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/subscriptions/${subscriptionId}/associate?workspace_id=${workspaceId}`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  async createSubscriptionPaymentLink(accountId, subscriptionId) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/subscriptions/${subscriptionId}/payment-link`, {
+      method: "POST"
+    });
+  }
+  // ===== Stripe Payment Methods Management =====
+  async createSetupIntent(accountId) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/setup-intent`, {
+      method: "POST"
+    });
+  }
+  async getStripePaymentMethods(accountId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/payment-methods`
+    );
+  }
+  async attachStripePaymentMethod(accountId, paymentMethodId, setAsDefault = false) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/payment-methods/${paymentMethodId}/attach`, {
+      method: "POST",
+      body: JSON.stringify({ setAsDefault })
+    });
+  }
+  async detachStripePaymentMethod(accountId, paymentMethodId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/payment-methods/${paymentMethodId}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async setDefaultStripePaymentMethod(accountId, paymentMethodId) {
+    return this.fetch(
+      `admin/accounts/${accountId}/stripe/payment-methods/${paymentMethodId}/set-default`,
+      {
+        method: "PUT"
+      }
+    );
+  }
+  // ===== Convert Direct Subscription to Stripe =====
+  async convertSubscriptionToStripe(customerId, subscriptionId) {
+    return this.fetch(
+      `admin/customers/${customerId}/subscriptions/${subscriptionId}/convert-to-stripe`,
+      { method: "POST" }
+    );
+  }
+  // ===== Customer-Level Stripe Payment Methods =====
+  async createCustomerSetupIntent(customerId) {
+    return this.fetch(`admin/customers/${customerId}/stripe/setup-intent`, {
+      method: "POST"
+    });
+  }
+  async getCustomerPaymentMethods(customerId) {
+    return this.fetch(
+      `admin/customers/${customerId}/stripe/payment-methods`
+    );
+  }
+  async attachCustomerPaymentMethod(customerId, paymentMethodId, setAsDefault = false) {
+    return this.fetch(`admin/customers/${customerId}/stripe/payment-methods/${paymentMethodId}/attach`, {
+      method: "POST",
+      body: JSON.stringify({ setAsDefault })
+    });
+  }
+  async detachCustomerPaymentMethod(customerId, paymentMethodId) {
+    return this.fetch(
+      `admin/customers/${customerId}/stripe/payment-methods/${paymentMethodId}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async setDefaultCustomerPaymentMethod(customerId, paymentMethodId) {
+    return this.fetch(
+      `admin/customers/${customerId}/stripe/payment-methods/${paymentMethodId}/set-default`,
+      {
+        method: "PUT"
+      }
+    );
+  }
+  // ===== Workspace Organization Migration =====
+  async previewWorkspaceOrganizationChange(workspaceUuid, targetOrganizationId, newCreatorId) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/change-org/preview`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        targetOrganizationId,
+        newCreatorId
+      })
+    });
+  }
+  async changeWorkspaceOrganization(workspaceUuid, targetOrganizationId, newCreatorId) {
+    return this.fetch(`admin/workspaces/${workspaceUuid}/change-org`, {
+      method: "POST",
+      body: JSON.stringify({
+        targetOrganizationId,
+        newCreatorId
+      })
+    });
+  }
+  // ===== Stripe Invoice Management =====
+  async createStripeInvoice(accountId, data) {
+    return this.fetch(`admin/accounts/${accountId}/stripe/invoices`, {
+      method: "POST",
+      body: JSON.stringify({
+        customer: data.customer,
+        description: data.description,
+        collection_method: data.collectionMethod,
+        days_until_due: data.daysUntilDue,
+        auto_advance: data.autoAdvance,
+        metadata: data.metadata
+      })
+    });
+  }
+  async getStripeInvoices(accountId, options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.append("limit", options.limit.toString());
+    if (options?.startingAfter) params.append("starting_after", options.startingAfter);
+    return this.fetch(`admin/accounts/${accountId}/stripe/invoices?${params.toString()}`);
+  }
+  async getStripeUpcomingInvoice(accountId, subscriptionId) {
+    const params = new URLSearchParams();
+    if (subscriptionId) params.append("subscription_id", subscriptionId);
+    return this.fetch(`admin/accounts/${accountId}/stripe/upcoming-invoice?${params.toString()}`);
+  }
+  // Billing Dashboard API
+  async getWorkspaceUsageDashboard(workspaceUuid) {
+    return this.fetch(
+      `admin/workspaces/${workspaceUuid}/usage-dashboard`
+    );
+  }
+  // Product Stripe Sync API
+  async compareProductsWithStripe(workspaceUuid) {
+    const params = workspaceUuid ? `?workspace_uuid=${encodeURIComponent(workspaceUuid)}` : "";
+    return this.fetch(`admin/products/compare-stripe${params}`);
+  }
+  async syncProductToStripe(productId, request) {
+    return this.fetch(`admin/products/${productId}/sync-stripe`, {
+      method: "POST",
+      body: JSON.stringify({ ...request, productId })
+    });
+  }
+  // Search Stripe products
+  async searchStripeProducts(query, limit = 10) {
+    const params = new URLSearchParams({ query, limit: limit.toString() });
+    return this.fetch(`admin/products/stripe/search?${params.toString()}`);
+  }
+  // ===== Subscriptions API =====
+  async getSubscriptionsAsAdmin(options) {
+    const params = new URLSearchParams();
+    if (options?.productId) params.append("product_id", options.productId.toString());
+    if (options?.productType) params.append("product_type", options.productType);
+    if (options?.customerId) params.append("customer_id", options.customerId.toString());
+    if (options?.organizationId)
+      params.append("organization_id", options.organizationId.toString());
+    if (options?.accountId) params.append("account_id", options.accountId.toString());
+    if (options?.isDirect !== void 0) params.append("is_direct", options.isDirect.toString());
+    if (options?.status) params.append("status", options.status);
+    if (options?.page) params.append("page", options.page.toString());
+    if (options?.pageSize) params.append("page_size", options.pageSize.toString());
+    const queryString = params.toString();
+    return this.fetch(
+      `admin/subscriptions${queryString ? `?${queryString}` : ""}`
+    );
+  }
+  async getSubscriptionAsAdmin(subscriptionId) {
+    return this.fetch(`admin/subscriptions/${subscriptionId}`);
+  }
+  async updateSubscriptionStatusAsAdmin(subscriptionId, subscriptionStatus) {
+    return this.fetch(`admin/subscriptions/${subscriptionId}`, {
+      method: "PUT",
+      body: JSON.stringify({ subscription_status: subscriptionStatus })
+    });
+  }
+  async updateSubscriptionCreditSettingsAsAdmin(subscriptionId, settings) {
+    return this.fetch(`admin/subscriptions/${subscriptionId}`, {
+      method: "PUT",
+      body: JSON.stringify(settings)
+    });
+  }
+  /** Grant credits to a subscription (superuser only). */
+  async grantCreditsAsAdmin(subscriptionId, creditUnits, grantType, reason) {
+    return this.fetch(`admin/subscriptions/${subscriptionId}/grant-credits`, {
+      method: "POST",
+      body: JSON.stringify({ credit_units: creditUnits, grant_type: grantType, reason })
+    });
+  }
+  /** List credit grants for a subscription (superuser only). */
+  async listCreditGrantsAsAdmin(subscriptionId) {
+    return this.fetch(`admin/subscriptions/${subscriptionId}/credit-grants`);
+  }
+  // ===== Usage API =====
+  async getUsageReport(request) {
+    return this.fetch("admin/usage", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  // Voice Metrics API
+  async getVoiceMetrics(options) {
+    const params = new URLSearchParams();
+    if (options?.hours) params.append("hours", options.hours.toString());
+    if (options?.period) params.append("period", options.period.toString());
+    if (options?.workspace_uuid) params.append("workspace_uuid", options.workspace_uuid);
+    if (options?.organization_id != null)
+      params.append("organization_id", options.organization_id.toString());
+    if (options?.engine) params.append("engine", options.engine);
+    if (options?.channel) params.append("channel", options.channel);
+    const qs = params.toString();
+    return this.fetch(`admin/voice-metrics${qs ? `?${qs}` : ""}`);
+  }
+  // Health Dashboard API
+  async getHealthMetrics(request) {
+    return this.fetch("admin/health/metrics", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getHealthDetail(workspaceUuid, request) {
+    return this.fetch(`admin/health/detail/${workspaceUuid}`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  // ===== Reseller Management =====
+  async getResellers(options) {
+    const params = new URLSearchParams();
+    if (options?.search) params.set("search", options.search);
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.pageSize) params.set("page_size", String(options.pageSize));
+    const qs = params.toString();
+    return this.fetch(`admin/resellers${qs ? `?${qs}` : ""}`);
+  }
+  async getReseller(resellerId) {
+    return this.fetch(`admin/resellers/${resellerId}`);
+  }
+  async createReseller(data) {
+    return this.fetch("admin/resellers", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateReseller(resellerId, data) {
+    return this.fetch(`admin/resellers/${resellerId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async getResellerAccounts(resellerId) {
+    return this.fetch(`admin/resellers/${resellerId}/accounts`);
+  }
+  async linkResellerToAccount(resellerId, data) {
+    return this.fetch(`admin/resellers/${resellerId}/accounts`, {
+      method: "POST",
+      body: JSON.stringify({ account_id: data.accountId, role: data.role })
+    });
+  }
+  async unlinkResellerFromAccount(resellerId, accountId) {
+    await this.fetch(`admin/resellers/${resellerId}/accounts/${accountId}`, {
+      method: "DELETE"
+    });
+  }
+  // ===== Invoice Management =====
+  async generateInvoice(data) {
+    return this.fetch("admin/invoices/generate", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getInvoices(subscriptionId, pageOpts) {
+    const params = new URLSearchParams();
+    if (subscriptionId !== void 0) params.set("subscription_id", String(subscriptionId));
+    if (pageOpts?.page !== void 0) params.set("page", String(pageOpts.page));
+    if (pageOpts?.pageSize !== void 0) params.set("pageSize", String(pageOpts.pageSize));
+    const qs = params.toString();
+    return this.fetch(`admin/invoices${qs ? `?${qs}` : ""}`);
+  }
+  async getBillingPeriods(subscriptionId) {
+    return this.fetch(
+      `admin/invoices/periods?subscription_id=${subscriptionId}`
+    );
+  }
+  async getInvoiceDownloadUrl(invoiceId) {
+    return this.fetch(
+      `admin/invoices/${invoiceId}/download`
+    );
+  }
+  async getReceiptDownloadUrl(invoiceId) {
+    return this.fetch(
+      `admin/invoices/${invoiceId}/receipt`
+    );
+  }
+  async recordInvoicePayment(invoiceId, data) {
+    return this.fetch(`admin/invoices/${invoiceId}/record-payment`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  // ===== Admin Temporal Inspection (PHI-safe, read-only) =====
+  /**
+   * Server-enforced bounds for admin Temporal queries (lookback, thresholds,
+   * page sizes, history event cap). Superuser only.
+   */
+  async getTemporalAdminConfig() {
+    return this.fetch("admin/temporal/config");
+  }
+  /**
+   * List recent Temporal workflows in FAILED, TIMED_OUT, or TERMINATED
+   * status. Returns only PHI-safe operational metadata. Superuser only.
+   *
+   * Pass `options.status` to filter to a single status and enable
+   * deep pagination via `nextPageToken`. Merged mode (no status) returns
+   * the first page only and always emits `nextPageToken: null`.
+   */
+  async listFailedTemporalWorkflows(options = {}) {
+    const params = new URLSearchParams();
+    if (options.lookbackHours !== void 0)
+      params.set("lookback_hours", String(options.lookbackHours));
+    if (options.pageSize !== void 0) params.set("page_size", String(options.pageSize));
+    if (options.status) params.set("status", String(options.status));
+    if (options.nextPageToken) params.set("next_page_token", options.nextPageToken);
+    appendTemporalWorkspaceParams(params, options);
+    const qs = params.toString();
+    return this.fetch(
+      `admin/temporal/workflows/failed${qs ? `?${qs}` : ""}`
+    );
+  }
+  /**
+   * List open Temporal workflows older than the stuck threshold.
+   * Superuser only.
+   */
+  async listStuckTemporalWorkflows(options = {}) {
+    const params = new URLSearchParams();
+    if (options.thresholdMinutes !== void 0)
+      params.set("threshold_minutes", String(options.thresholdMinutes));
+    if (options.pageSize !== void 0) params.set("page_size", String(options.pageSize));
+    if (options.nextPageToken) params.set("next_page_token", options.nextPageToken);
+    appendTemporalWorkspaceParams(params, options);
+    const qs = params.toString();
+    return this.fetch(
+      `admin/temporal/workflows/stuck${qs ? `?${qs}` : ""}`
+    );
+  }
+  /**
+   * Return grouped counts for recent Temporal executions. Superuser only.
+   */
+  async getTemporalSummary(options = {}) {
+    const params = new URLSearchParams();
+    if (options.lookbackHours !== void 0)
+      params.set("lookback_hours", String(options.lookbackHours));
+    appendTemporalWorkspaceParams(params, options);
+    const qs = params.toString();
+    return this.fetch(
+      `admin/temporal/workflows/summary${qs ? `?${qs}` : ""}`
+    );
+  }
+  /**
+   * Fetch metadata + bounded sanitized history summary for one Temporal
+   * workflow. Superuser only. Does not return raw events or payloads.
+   */
+  async getTemporalWorkflowDetail(workflowId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.runId) params.set("run_id", options.runId);
+    appendTemporalWorkspaceParams(params, options);
+    const qs = params.toString();
+    const encoded = encodeURIComponent(workflowId);
+    return this.fetch(
+      `admin/temporal/workflows/${encoded}${qs ? `?${qs}` : ""}`
+    );
+  }
+};
+function appendTemporalWorkspaceParams(params, options) {
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw) => {
+    if (!raw) return;
+    const trimmed = raw.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    params.append("workspace_uuid", trimmed);
+  };
+  if (options.workspaceUuids) {
+    for (const value of options.workspaceUuids) push(value);
+  }
+  push(options.workspaceUuid);
+}
+function bindAdminMethods(target, admin) {
+  target.getAccounts = admin.getAccounts.bind(admin);
+  target.getAccountDetails = admin.getAccountDetails.bind(admin);
+  target.getAccountByUuid = admin.getAccountByUuid.bind(admin);
+  target.getAccountMemberships = admin.getAccountMemberships.bind(admin);
+  target.getAccountOrgMemberships = admin.getAccountOrgMemberships.bind(admin);
+  target.createAccountOrgMembership = admin.createAccountOrgMembership.bind(admin);
+  target.deleteAccountOrgMembership = admin.deleteAccountOrgMembership.bind(admin);
+  target.getAccountMembership = admin.getAccountMembership.bind(admin);
+  target.updateAccountMembership = admin.updateAccountMembership.bind(admin);
+  target.createAccountMembership = admin.createAccountMembership.bind(admin);
+  target.deleteAccountMembership = admin.deleteAccountMembership.bind(admin);
+  target.updateAccountAsAdmin = admin.updateAccountAsAdmin.bind(admin);
+  target.createAccountAsAdmin = admin.createAccountAsAdmin.bind(admin);
+  target.deleteAccountAsAdmin = admin.deleteAccountAsAdmin.bind(admin);
+  target.lookupAccount = admin.lookupAccount.bind(admin);
+  target.exportAccountData = admin.exportAccountData.bind(admin);
+  target.requestAccountDeletion = admin.requestAccountDeletion.bind(admin);
+  target.cancelAccountDeletion = admin.cancelAccountDeletion.bind(admin);
+  target.getOrganizations = admin.getOrganizations.bind(admin);
+  target.getOrganization = admin.getOrganization.bind(admin);
+  target.getOrganizationAsAdmin = admin.getOrganizationAsAdmin.bind(admin);
+  target.getOrganizationMembersAsAdmin = admin.getOrganizationMembersAsAdmin.bind(admin);
+  target.createOrganization = admin.createOrganization.bind(admin);
+  target.updateOrganization = admin.updateOrganization.bind(admin);
+  target.deleteOrganization = admin.deleteOrganization.bind(admin);
+  target.joinOrganization = admin.joinOrganization.bind(admin);
+  target.leaveOrganization = admin.leaveOrganization.bind(admin);
+  target.generateLogoUploadUrl = admin.generateLogoUploadUrl.bind(admin);
+  target.importProducts = admin.importProducts.bind(admin);
+  target.createProductAsAdmin = admin.createProductAsAdmin.bind(admin);
+  target.getProductsAsAdmin = admin.getProductsAsAdmin.bind(admin);
+  target.getProductAsAdmin = admin.getProductAsAdmin.bind(admin);
+  target.updateProductAsAdmin = admin.updateProductAsAdmin.bind(admin);
+  target.deleteProductAsAdmin = admin.deleteProductAsAdmin.bind(admin);
+  target.getWorkspacesAsAdmin = admin.getWorkspacesAsAdmin.bind(admin);
+  target.getWorkspaceAsAdmin = admin.getWorkspaceAsAdmin.bind(admin);
+  target.getWorkspaceByNumericIdAsAdmin = admin.getWorkspaceByNumericIdAsAdmin.bind(admin);
+  target.createWorkspaceAsAdmin = admin.createWorkspaceAsAdmin.bind(admin);
+  target.updateWorkspaceAsAdmin = admin.updateWorkspaceAsAdmin.bind(admin);
+  target.deleteWorkspaceAsAdmin = admin.deleteWorkspaceAsAdmin.bind(admin);
+  target.createSchemaAsAdmin = admin.createSchemaAsAdmin.bind(admin);
+  target.migrateSchemaAsAdmin = admin.migrateSchemaAsAdmin.bind(admin);
+  target.provisionWorkspaceAsAdmin = admin.provisionWorkspaceAsAdmin.bind(admin);
+  target.refreshProvisionStatusAsAdmin = admin.refreshProvisionStatusAsAdmin.bind(admin);
+  target.enableMaintenanceMode = admin.enableMaintenanceMode.bind(admin);
+  target.disableMaintenanceMode = admin.disableMaintenanceMode.bind(admin);
+  target.getWorkspaceHealth = admin.getWorkspaceHealth.bind(admin);
+  target.provisionPlanFeatures = admin.provisionPlanFeatures.bind(admin);
+  target.validateWorkflowAccessAsAdmin = admin.validateWorkflowAccessAsAdmin.bind(admin);
+  target.mergeMembers = admin.mergeMembers.bind(admin);
+  target.getAdminWorkspaceMember = admin.getAdminWorkspaceMember.bind(admin);
+  target.createAdminWorkspaceMember = admin.createAdminWorkspaceMember.bind(admin);
+  target.updateAdminWorkspaceMember = admin.updateAdminWorkspaceMember.bind(admin);
+  target.getAdminWorkspaceMemberRoles = admin.getAdminWorkspaceMemberRoles.bind(admin);
+  target.getMissingMemberships = admin.getMissingMemberships.bind(admin);
+  target.linkMissingMembership = admin.linkMissingMembership.bind(admin);
+  target.getUnmappedPhoneNumbers = admin.getUnmappedPhoneNumbers.bind(admin);
+  target.getWorkspaceUnmappedPhoneNumbers = admin.getWorkspaceUnmappedPhoneNumbers.bind(admin);
+  target.getWorkspacePhoneNumbersAsAdmin = admin.getWorkspacePhoneNumbersAsAdmin.bind(admin);
+  target.getProviderPhoneNumbers = admin.getProviderPhoneNumbers.bind(admin);
+  target.getProviderPhoneNumber = admin.getProviderPhoneNumber.bind(admin);
+  target.updateProviderPhoneNumber = admin.updateProviderPhoneNumber.bind(admin);
+  target.mapMainAccountPhone = admin.mapMainAccountPhone.bind(admin);
+  target.unmapPhoneNumber = admin.unmapPhoneNumber.bind(admin);
+  target.searchAvailablePhoneNumbersAsAdmin = admin.searchAvailablePhoneNumbersAsAdmin.bind(admin);
+  target.purchasePhoneNumberAsAdmin = admin.purchasePhoneNumberAsAdmin.bind(admin);
+  target.startBulkPhoneClassification = admin.startBulkPhoneClassification.bind(admin);
+  target.getOrgA2PStatusAsAdmin = admin.getOrgA2PStatusAsAdmin.bind(admin);
+  target.resetOrgA2PStatusAsAdmin = admin.resetOrgA2PStatusAsAdmin.bind(admin);
+  target.getSiteMappings = admin.getSiteMappings.bind(admin);
+  target.getSiteMapping = admin.getSiteMapping.bind(admin);
+  target.updateSiteMapping = admin.updateSiteMapping.bind(admin);
+  target.updateSiteMappingWorkspace = admin.updateSiteMappingWorkspace.bind(admin);
+  target.adminDeleteSiteMapping = admin.adminDeleteSiteMapping.bind(admin);
+  target.createSiteMapping = admin.createSiteMapping.bind(admin);
+  target.createOrUpdateSiteMapping = admin.createOrUpdateSiteMapping.bind(admin);
+  target.deleteSiteMapping = admin.deleteSiteMapping.bind(admin);
+  target.getInboxMappings = admin.getInboxMappings.bind(admin);
+  target.getInboxMapping = admin.getInboxMapping.bind(admin);
+  target.updateInboxMapping = admin.updateInboxMapping.bind(admin);
+  target.deleteAdminInboxMapping = admin.deleteAdminInboxMapping.bind(admin);
+  target.generateChatSummaries = admin.generateChatSummaries.bind(admin);
+  target.executeQuery = admin.executeQuery.bind(admin);
+  target.listAllThemes = admin.listAllThemes.bind(admin);
+  target.migrateRoutineCadenceKeys = admin.migrateRoutineCadenceKeys.bind(admin);
+  target.startBulkTOSAcceptance = admin.startBulkTOSAcceptance.bind(admin);
+  target.startTokenUsageBackfill = admin.startTokenUsageBackfill.bind(admin);
+  target.updateChatMessage = admin.updateChatMessage.bind(admin);
+  target.createCustomerFromAccount = admin.createCustomerFromAccount.bind(admin);
+  target.getCustomers = admin.getCustomers.bind(admin);
+  target.getCustomer = admin.getCustomer.bind(admin);
+  target.createCustomer = admin.createCustomer.bind(admin);
+  target.updateCustomer = admin.updateCustomer.bind(admin);
+  target.getCustomerAccounts = admin.getCustomerAccounts.bind(admin);
+  target.linkCustomerToAccount = admin.linkCustomerToAccount.bind(admin);
+  target.unlinkCustomerFromAccount = admin.unlinkCustomerFromAccount.bind(admin);
+  target.syncCustomerToStripe = admin.syncCustomerToStripe.bind(admin);
+  target.getStripeCustomer = admin.getStripeCustomer.bind(admin);
+  target.createStripeCustomer = admin.createStripeCustomer.bind(admin);
+  target.updateStripeCustomer = admin.updateStripeCustomer.bind(admin);
+  target.getStripeSubscriptions = admin.getStripeSubscriptions.bind(admin);
+  target.createStripeSubscription = admin.createStripeSubscription.bind(admin);
+  target.createDirectSubscription = admin.createDirectSubscription.bind(admin);
+  target.updateStripeSubscription = admin.updateStripeSubscription.bind(admin);
+  target.cancelStripeSubscription = admin.cancelStripeSubscription.bind(admin);
+  target.provisionWorkspaceForSubscription = admin.provisionWorkspaceForSubscription.bind(admin);
+  target.associateWorkspaceWithSubscription = admin.associateWorkspaceWithSubscription.bind(admin);
+  target.createSubscriptionPaymentLink = admin.createSubscriptionPaymentLink.bind(admin);
+  target.createSetupIntent = admin.createSetupIntent.bind(admin);
+  target.getStripePaymentMethods = admin.getStripePaymentMethods.bind(admin);
+  target.attachStripePaymentMethod = admin.attachStripePaymentMethod.bind(admin);
+  target.detachStripePaymentMethod = admin.detachStripePaymentMethod.bind(admin);
+  target.setDefaultStripePaymentMethod = admin.setDefaultStripePaymentMethod.bind(admin);
+  target.convertSubscriptionToStripe = admin.convertSubscriptionToStripe.bind(admin);
+  target.createCustomerSetupIntent = admin.createCustomerSetupIntent.bind(admin);
+  target.getCustomerPaymentMethods = admin.getCustomerPaymentMethods.bind(admin);
+  target.attachCustomerPaymentMethod = admin.attachCustomerPaymentMethod.bind(admin);
+  target.detachCustomerPaymentMethod = admin.detachCustomerPaymentMethod.bind(admin);
+  target.setDefaultCustomerPaymentMethod = admin.setDefaultCustomerPaymentMethod.bind(admin);
+  target.previewWorkspaceOrganizationChange = admin.previewWorkspaceOrganizationChange.bind(admin);
+  target.changeWorkspaceOrganization = admin.changeWorkspaceOrganization.bind(admin);
+  target.createStripeInvoice = admin.createStripeInvoice.bind(admin);
+  target.getStripeInvoices = admin.getStripeInvoices.bind(admin);
+  target.getStripeUpcomingInvoice = admin.getStripeUpcomingInvoice.bind(admin);
+  target.getBillingPeriods = admin.getBillingPeriods.bind(admin);
+  target.generateInvoice = admin.generateInvoice.bind(admin);
+  target.getInvoices = admin.getInvoices.bind(admin);
+  target.getInvoiceDownloadUrl = admin.getInvoiceDownloadUrl.bind(admin);
+  target.getReceiptDownloadUrl = admin.getReceiptDownloadUrl.bind(admin);
+  target.recordInvoicePayment = admin.recordInvoicePayment.bind(admin);
+  target.getWorkspaceUsageDashboard = admin.getWorkspaceUsageDashboard.bind(admin);
+  target.compareProductsWithStripe = admin.compareProductsWithStripe.bind(admin);
+  target.syncProductToStripe = admin.syncProductToStripe.bind(admin);
+  target.searchStripeProducts = admin.searchStripeProducts.bind(admin);
+  target.getUsageReport = admin.getUsageReport.bind(admin);
+  target.getSubscriptionsAsAdmin = admin.getSubscriptionsAsAdmin.bind(admin);
+  target.getSubscriptionAsAdmin = admin.getSubscriptionAsAdmin.bind(admin);
+  target.updateSubscriptionStatusAsAdmin = admin.updateSubscriptionStatusAsAdmin.bind(admin);
+  target.updateSubscriptionCreditSettingsAsAdmin = admin.updateSubscriptionCreditSettingsAsAdmin.bind(admin);
+  target.grantCreditsAsAdmin = admin.grantCreditsAsAdmin.bind(admin);
+  target.listCreditGrantsAsAdmin = admin.listCreditGrantsAsAdmin.bind(admin);
+  target.getVoiceMetrics = admin.getVoiceMetrics.bind(admin);
+  target.getHealthMetrics = admin.getHealthMetrics.bind(admin);
+  target.getHealthDetail = admin.getHealthDetail.bind(admin);
+  target.listWorkspaceChats = admin.listWorkspaceChats.bind(admin);
+  target.getWorkspaceChat = admin.getWorkspaceChat.bind(admin);
+  target.rateWorkspaceChatMessage = admin.rateWorkspaceChatMessage.bind(admin);
+  target.getTemporalAdminConfig = admin.getTemporalAdminConfig.bind(admin);
+  target.listFailedTemporalWorkflows = admin.listFailedTemporalWorkflows.bind(admin);
+  target.listStuckTemporalWorkflows = admin.listStuckTemporalWorkflows.bind(admin);
+  target.getTemporalSummary = admin.getTemporalSummary.bind(admin);
+  target.getTemporalWorkflowDetail = admin.getTemporalWorkflowDetail.bind(admin);
+  target.getResellers = admin.getResellers.bind(admin);
+  target.getReseller = admin.getReseller.bind(admin);
+  target.createReseller = admin.createReseller.bind(admin);
+  target.updateReseller = admin.updateReseller.bind(admin);
+  target.getResellerAccounts = admin.getResellerAccounts.bind(admin);
+  target.linkResellerToAccount = admin.linkResellerToAccount.bind(admin);
+  target.unlinkResellerFromAccount = admin.unlinkResellerFromAccount.bind(admin);
+}
+var ApiClient = class extends GravityRailClient {
+  // Admin API
+  getAccounts;
+  getAccountDetails;
+  getAccountByUuid;
+  getAccountMemberships;
+  getAccountOrgMemberships;
+  createAccountOrgMembership;
+  deleteAccountOrgMembership;
+  getAccountMembership;
+  updateAccountMembership;
+  createAccountMembership;
+  deleteAccountMembership;
+  updateAccountAsAdmin;
+  createAccountAsAdmin;
+  deleteAccountAsAdmin;
+  lookupAccount;
+  exportAccountData;
+  requestAccountDeletion;
+  cancelAccountDeletion;
+  getOrganizations;
+  getOrganization;
+  getOrganizationAsAdmin;
+  getOrganizationMembersAsAdmin;
+  createOrganization;
+  updateOrganization;
+  deleteOrganization;
+  joinOrganization;
+  leaveOrganization;
+  generateLogoUploadUrl;
+  importProducts;
+  createProductAsAdmin;
+  getProductsAsAdmin;
+  getProductAsAdmin;
+  updateProductAsAdmin;
+  deleteProductAsAdmin;
+  getWorkspacesAsAdmin;
+  getWorkspaceAsAdmin;
+  getWorkspaceByNumericIdAsAdmin;
+  createWorkspaceAsAdmin;
+  updateWorkspaceAsAdmin;
+  deleteWorkspaceAsAdmin;
+  createSchemaAsAdmin;
+  migrateSchemaAsAdmin;
+  provisionWorkspaceAsAdmin;
+  refreshProvisionStatusAsAdmin;
+  enableMaintenanceMode;
+  disableMaintenanceMode;
+  getWorkspaceHealth;
+  provisionPlanFeatures;
+  validateWorkflowAccessAsAdmin;
+  mergeMembers;
+  getAdminWorkspaceMember;
+  createAdminWorkspaceMember;
+  updateAdminWorkspaceMember;
+  getAdminWorkspaceMemberRoles;
+  getMissingMemberships;
+  linkMissingMembership;
+  getUnmappedPhoneNumbers;
+  getWorkspaceUnmappedPhoneNumbers;
+  getWorkspacePhoneNumbersAsAdmin;
+  getProviderPhoneNumbers;
+  getProviderPhoneNumber;
+  updateProviderPhoneNumber;
+  mapMainAccountPhone;
+  unmapPhoneNumber;
+  searchAvailablePhoneNumbersAsAdmin;
+  purchasePhoneNumberAsAdmin;
+  startBulkPhoneClassification;
+  getOrgA2PStatusAsAdmin;
+  resetOrgA2PStatusAsAdmin;
+  getSiteMappings;
+  getSiteMapping;
+  updateSiteMapping;
+  updateSiteMappingWorkspace;
+  adminDeleteSiteMapping;
+  createSiteMapping;
+  createOrUpdateSiteMapping;
+  deleteSiteMapping;
+  getInboxMappings;
+  getInboxMapping;
+  updateInboxMapping;
+  deleteAdminInboxMapping;
+  generateChatSummaries;
+  executeQuery;
+  listAllThemes;
+  migrateRoutineCadenceKeys;
+  startBulkTOSAcceptance;
+  startTokenUsageBackfill;
+  updateChatMessage;
+  createCustomerFromAccount;
+  getCustomers;
+  getCustomer;
+  createCustomer;
+  updateCustomer;
+  getCustomerAccounts;
+  linkCustomerToAccount;
+  unlinkCustomerFromAccount;
+  syncCustomerToStripe;
+  getStripeCustomer;
+  createStripeCustomer;
+  updateStripeCustomer;
+  getStripeSubscriptions;
+  createStripeSubscription;
+  createDirectSubscription;
+  updateStripeSubscription;
+  cancelStripeSubscription;
+  provisionWorkspaceForSubscription;
+  associateWorkspaceWithSubscription;
+  createSubscriptionPaymentLink;
+  createSetupIntent;
+  getStripePaymentMethods;
+  attachStripePaymentMethod;
+  detachStripePaymentMethod;
+  setDefaultStripePaymentMethod;
+  createCustomerSetupIntent;
+  getCustomerPaymentMethods;
+  attachCustomerPaymentMethod;
+  detachCustomerPaymentMethod;
+  setDefaultCustomerPaymentMethod;
+  convertSubscriptionToStripe;
+  previewWorkspaceOrganizationChange;
+  changeWorkspaceOrganization;
+  createStripeInvoice;
+  getStripeInvoices;
+  getStripeUpcomingInvoice;
+  getWorkspaceUsageDashboard;
+  compareProductsWithStripe;
+  syncProductToStripe;
+  searchStripeProducts;
+  getUsageReport;
+  getSubscriptionsAsAdmin;
+  getSubscriptionAsAdmin;
+  updateSubscriptionStatusAsAdmin;
+  updateSubscriptionCreditSettingsAsAdmin;
+  grantCreditsAsAdmin;
+  listCreditGrantsAsAdmin;
+  getVoiceMetrics;
+  getHealthMetrics;
+  getHealthDetail;
+  listWorkspaceChats;
+  getWorkspaceChat;
+  rateWorkspaceChatMessage;
+  getTemporalAdminConfig;
+  listFailedTemporalWorkflows;
+  listStuckTemporalWorkflows;
+  getTemporalSummary;
+  getTemporalWorkflowDetail;
+  getResellers;
+  getReseller;
+  createReseller;
+  updateReseller;
+  getResellerAccounts;
+  linkResellerToAccount;
+  unlinkResellerFromAccount;
+  getBillingPeriods;
+  generateInvoice;
+  getInvoices;
+  getInvoiceDownloadUrl;
+  getReceiptDownloadUrl;
+  recordInvoicePayment;
+  adminApi;
+  constructor(apiKey, baseUrl3, customFetch) {
+    super(apiKey, baseUrl3, customFetch);
+    this.adminApi = new AdminApi(apiKey, baseUrl3, customFetch);
+    bindAdminMethods(this, this.adminApi);
+  }
+  /**
+   * Propagates acting member switches to the admin API module as well.
+   */
+  setActingMember(memberUuid) {
+    super.setActingMember(memberUuid);
+    if (typeof this.adminApi.setActingMember === "function") {
+      this.adminApi.setActingMember(memberUuid);
+    }
+  }
+};
+
+// src/lib/context.ts
 import { homedir } from "os";
 
 // src/lib/output.ts
@@ -448,7 +1902,7 @@ async function tryTokenRefresh(ctx, creds) {
     ctx.env
   );
   if (!refreshed?.accessToken) return null;
-  const apiClient = new GravityRailClient(refreshed.accessToken, ctx.envConfig.apiUrl);
+  const apiClient = new ApiClient(refreshed.accessToken, ctx.envConfig.apiUrl);
   return { ...ctx, accessToken: refreshed.accessToken, apiClient };
 }
 function createContext(opts) {
@@ -472,12 +1926,12 @@ async function createAuthenticatedContext(opts) {
       devRealmsPath = loadDevCloudRealmFile(namespace);
     }
     const { token, workspaceUuid } = loadRealmCredentials(opts.realm, devRealmsPath);
-    const apiClient = new GravityRailClient(token, ctx.envConfig.apiUrl);
+    const apiClient = new ApiClient(token, ctx.envConfig.apiUrl);
     return { ...ctx, accessToken: token, apiClient, realmWorkspace: workspaceUuid };
   }
   const apiKey = process.env.GRAVITY_RAIL_API_KEY;
   if (apiKey) {
-    const apiClient = new GravityRailClient(apiKey, ctx.envConfig.apiUrl);
+    const apiClient = new ApiClient(apiKey, ctx.envConfig.apiUrl);
     return { ...ctx, accessToken: apiKey, apiClient };
   }
   const creds = ctx.credentialsManager.load(ctx.env);
@@ -485,7 +1939,7 @@ async function createAuthenticatedContext(opts) {
     const buffer = 5 * 60 * 1e3;
     const notExpired = !creds.expiresAt || new Date(creds.expiresAt) > new Date(Date.now() + buffer);
     if (notExpired) {
-      const apiClient = new GravityRailClient(creds.accessToken, ctx.envConfig.apiUrl);
+      const apiClient = new ApiClient(creds.accessToken, ctx.envConfig.apiUrl);
       return { ...ctx, accessToken: creds.accessToken, apiClient };
     }
     const refreshed = await tryTokenRefresh(ctx, creds);
@@ -517,7 +1971,7 @@ async function createPublicAuthenticatedContext(opts) {
   const ctx = createPublicContext(opts);
   const apiKey = process.env.GRAVITY_RAIL_API_KEY;
   if (apiKey) {
-    const apiClient = new GravityRailClient(apiKey, ctx.envConfig.apiUrl);
+    const apiClient = new ApiClient(apiKey, ctx.envConfig.apiUrl);
     return { ...ctx, accessToken: apiKey, apiClient };
   }
   const creds = ctx.credentialsManager.load(ctx.env);
@@ -525,7 +1979,7 @@ async function createPublicAuthenticatedContext(opts) {
     const buffer = 5 * 60 * 1e3;
     const notExpired = !creds.expiresAt || new Date(creds.expiresAt) > new Date(Date.now() + buffer);
     if (notExpired) {
-      const apiClient = new GravityRailClient(creds.accessToken, ctx.envConfig.apiUrl);
+      const apiClient = new ApiClient(creds.accessToken, ctx.envConfig.apiUrl);
       return { ...ctx, accessToken: creds.accessToken, apiClient };
     }
     const refreshed = await tryTokenRefresh(ctx, creds);
@@ -1358,6 +2812,10 @@ var MESSAGE_COLUMNS2 = [
     getValue: (item) => String(item.content ?? "").slice(0, 80),
     maxWidth: 80
   },
+  {
+    header: "TOOL_CALLS",
+    getValue: (item) => Array.isArray(item.tool_calls) && item.tool_calls.length > 0 ? item.tool_calls.map((t) => t.function?.name ?? "?").join(",") : ""
+  },
   COL.created()
 ];
 var chatsDomain = {
@@ -1391,13 +2849,35 @@ var chatsDomain = {
     // Messages
     {
       path: ["chats", "messages", "list"],
-      description: "List messages for a chat",
+      description: "List messages for a chat. Use --limit/--offset to page; the API caps a single request at 100. Tool-call shell rows that the API filter excludes (parent_message_id IS NOT NULL or parent_call_id IS NOT NULL) are still hidden \u2014 use `gr chats inspect --id <chat>` for the full debug view.",
       requiresWorkspace: true,
-      args: [{ name: "chat-id", description: "Chat ID", required: true }],
+      args: [
+        { name: "chat-id", description: "Chat ID", required: true },
+        {
+          name: "limit",
+          description: "Max messages to return (1-100, default 100)"
+        },
+        {
+          name: "offset",
+          description: "Offset for pagination (default 0)"
+        }
+      ],
       handler: async ({ ctx, workspace, args }) => {
+        const rawLimit = args.limit;
+        const rawOffset = args.offset;
+        const limit = rawLimit === void 0 || rawLimit === null || rawLimit === "" ? 100 : Number(rawLimit);
+        const offset = rawOffset === void 0 || rawOffset === null || rawOffset === "" ? 0 : Number(rawOffset);
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+          throw new Error("--limit must be an integer between 1 and 100");
+        }
+        if (!Number.isInteger(offset) || offset < 0) {
+          throw new Error("--offset must be a non-negative integer");
+        }
         const result = await requireAuth(ctx).apiClient.getChatMessages(
           workspace,
-          requireNumber(args, "chat-id")
+          requireNumber(args, "chat-id"),
+          limit,
+          offset
         );
         outputData(result, ctx, MESSAGE_COLUMNS2);
       }
@@ -3512,6 +4992,11 @@ var eventRulesCrud = crudCommands({
   createMethod: "createEventRule",
   updateMethod: "updateEventRule",
   deleteMethod: "deleteEventRule",
+  // The endpoint is paginated and excludes nothing by object_type. Without
+  // 'full', the CLI silently returned only page 1 (default 25 rules), which
+  // hid routine/journey/calendar-scoped rules in workspaces with many
+  // task-scoped rules. 'full' wires up --page/--page-size and --all.
+  paginationSupport: "full",
   columns: RULE_COLUMNS,
   createExamples: [
     `gr events rules create -w $WID --data '{"name":"Label on step","objectType":"journey",`,
@@ -3559,6 +5044,48 @@ var eventsDomain = {
         outputData(result, ctx);
       }
     },
+    {
+      // The /event-rules/search endpoint returns an unpaginated list — the
+      // server applies the filters and returns whatever matches. No --all
+      // flag is needed; if the result becomes too large in practice,
+      // tighten the filter rather than paginate.
+      path: ["events", "rules", "search"],
+      description: "Search event rules by object/event/action type or related entity ID",
+      requiresWorkspace: true,
+      args: [
+        {
+          name: "object-type",
+          description: "Filter by object type (task, routine, journey, workflow, calendar, ...)"
+        },
+        { name: "event-type", description: "Filter by event type" },
+        { name: "action-type", description: "Filter by action type" },
+        { name: "task-id", description: "Filter by task ID" },
+        { name: "data-type-id", description: "Filter by data type ID" },
+        { name: "routine-id", description: "Filter by routine ID" },
+        { name: "workflow-id", description: "Filter by workflow ID" },
+        { name: "journey-step-id", description: "Filter by journey step ID" },
+        {
+          name: "include-disabled",
+          description: "Include inactive rules (default: active only)"
+        }
+      ],
+      columns: RULE_COLUMNS,
+      handler: async ({ ctx, workspace, args }) => {
+        const opts = {};
+        if (args["object-type"]) opts.objectType = args["object-type"];
+        if (args["event-type"]) opts.eventType = args["event-type"];
+        if (args["action-type"]) opts.actionType = args["action-type"];
+        if (args["task-id"]) opts.taskId = requireNumber(args, "task-id");
+        if (args["data-type-id"]) opts.dataTypeId = requireNumber(args, "data-type-id");
+        if (args["routine-id"]) opts.routineId = requireNumber(args, "routine-id");
+        if (args["workflow-id"]) opts.workflowId = requireNumber(args, "workflow-id");
+        if (args["journey-step-id"])
+          opts.journeyStepId = requireNumber(args, "journey-step-id");
+        if (args["include-disabled"]) opts.includeDisabled = true;
+        const result = await requireAuth(ctx).apiClient.searchEventRules(workspace, opts);
+        outputData(result, ctx, RULE_COLUMNS);
+      }
+    },
     // Routines
     ...crudCommands({
       prefix: ["routines"],
@@ -5963,8 +7490,9 @@ var mcpServersDomain = {
 // src/domains/member-memories.ts
 var COLUMNS21 = [
   { header: "KEY", getValue: (item) => item.key ?? "" },
-  { header: "STRATEGY", getValue: (item) => item.strategy ?? "" },
-  { header: "CONTENT", getValue: (item) => truncate(item.content ?? "", 80) },
+  { header: "TYPE", getValue: (item) => item.type ?? "basic" },
+  { header: "DESCRIPTION", getValue: (item) => truncate(item.description ?? "", 60) },
+  { header: "PRIORITY", getValue: (item) => item.priority ?? 0 },
   { header: "UPDATED", getValue: (item) => item.updatedAt ?? item.createdAt ?? "" }
 ];
 function truncate(s, max) {
@@ -5972,7 +7500,7 @@ function truncate(s, max) {
 }
 var memberMemoriesDomain = {
   name: "member-memories",
-  description: "Manage member long-term memories",
+  description: "Manage member persistent memories",
   commands: [
     {
       path: ["member-memories", "list"],
@@ -5981,38 +7509,18 @@ var memberMemoriesDomain = {
       args: [
         { name: "member-id", description: "Member ID", required: true },
         {
-          name: "strategy",
-          description: "Filter by strategy (preferences, semantic, summaries, episodic)"
-        }
-      ],
-      handler: async ({ ctx, workspace, args }) => {
-        const memberId = requireNumber(args, "member-id");
-        const strategy = args.strategy;
-        const result = await requireAuth(ctx).apiClient.getMemberMemories(workspace, memberId, {
-          strategy
-        });
-        outputData(listResult(result, false), ctx, COLUMNS21);
-      }
-    },
-    {
-      path: ["member-memories", "search"],
-      description: "Search memories for a member by query",
-      requiresWorkspace: true,
-      args: [
-        { name: "member-id", description: "Member ID", required: true },
-        { name: "query", description: "Search query", required: true },
-        {
-          name: "strategy",
-          description: "Filter by strategy (preferences, semantic, summaries, episodic)"
-        }
+          name: "type",
+          description: "Memory type filter (basic, preferences, semantic, summaries, episodic, all)"
+        },
+        { name: "query", description: "Semantic search query (for AgentCore memory types)" }
       ],
       handler: async ({ ctx, workspace, args }) => {
         const memberId = requireNumber(args, "member-id");
-        const query = requireString(args, "query");
-        const strategy = args.strategy;
+        const type = args.type;
+        const query = args.query;
         const result = await requireAuth(ctx).apiClient.getMemberMemories(workspace, memberId, {
-          query,
-          strategy
+          type,
+          query
         });
         outputData(listResult(result, false), ctx, COLUMNS21);
       }
@@ -6025,17 +7533,20 @@ var memberMemoriesDomain = {
       args: [
         { name: "member-id", description: "Member ID", required: true },
         { name: "key", description: "Memory key", required: true },
-        { name: "strategy", description: "Memory strategy", required: true }
+        {
+          name: "type",
+          description: "Memory type (basic, preferences, semantic, summaries, episodic)"
+        }
       ],
       handler: async ({ ctx, workspace, args }) => {
         const memberId = requireNumber(args, "member-id");
         const key = requireString(args, "key");
-        const strategy = requireString(args, "strategy");
+        const type = args.type;
         await requireAuth(ctx).apiClient.deleteMemberMemory(
           workspace,
           memberId,
           key,
-          strategy
+          type ? { type } : void 0
         );
         process.stdout.write(`Deleted memory ${key}
 `);
@@ -6221,13 +7732,339 @@ var operatorGroupsDomain = {
 
 // src/domains/org.ts
 var ORG_COLUMNS = [
-  COL.id(),
-  COL.name(),
-  { header: "ROLE", getValue: (item) => item.role ?? "" }
+  { header: "ID", getValue: (item) => String(item.organizationId ?? "") },
+  { header: "NAME", getValue: (item) => item.organizationName || "" },
+  { header: "ROLE", getValue: (item) => item.role || "" }
+];
+var ORG_DOMAIN_COLUMNS = [
+  { header: "UUID", getValue: (item) => item.uuid ?? "" },
+  { header: "DOMAIN", getValue: (item) => item.domain ?? "" },
+  { header: "OWNERSHIP", getValue: (item) => item.ownershipStatus ?? "" },
+  { header: "EMAIL", getValue: (item) => item.emailStatus ?? "-" },
+  { header: "SITE", getValue: (item) => item.siteStatus ?? "-" },
+  { header: "TXT HOST", getValue: (item) => item.ownershipDnsRecord?.host ?? "" },
+  {
+    header: "TXT VALUE",
+    getValue: (item) => item.ownershipDnsRecord?.value ?? "",
+    maxWidth: 80
+  }
+];
+function requireOrgId(args) {
+  const val = args["org-uuid"] ?? args.org;
+  if (typeof val !== "string" || !val) {
+    throw new CLIError("Missing required argument: --org-uuid");
+  }
+  return val;
+}
+function requireDomainUuid(args) {
+  const val = args["domain-uuid"] ?? args.uuid;
+  if (typeof val !== "string" || !val) {
+    throw new CLIError("Missing required argument: --domain-uuid");
+  }
+  return val;
+}
+function requireDomain(args) {
+  const val = args.domain;
+  if (typeof val !== "string" || !val) {
+    throw new CLIError("Missing required argument: --domain");
+  }
+  return val;
+}
+var ORG_UUID_ARG = {
+  name: "org-uuid",
+  aliases: ["org"],
+  description: "Organization UUID or ID",
+  required: true
+};
+var DOMAIN_UUID_ARG = {
+  name: "domain-uuid",
+  aliases: ["domain-id"],
+  description: "OrgDomain UUID",
+  required: true
+};
+function pluralize(count, singular, plural = `${singular}s`) {
+  return count === 1 ? singular : plural;
+}
+function emailVerifyCommand(path, description) {
+  return {
+    path,
+    description,
+    mutates: true,
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: [
+      `yarn gr ${path.join(" ")} --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --allow-write`
+    ],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.verifyOrgDomainEmail(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  };
+}
+function siteVerifyCommand(path, description) {
+  return {
+    path,
+    description,
+    mutates: true,
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: [
+      `yarn gr ${path.join(" ")} --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --allow-write`
+    ],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.verifyOrgDomainSite(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  };
+}
+function registerDomainCommand(path) {
+  return {
+    path,
+    description: "Register an organization domain and return ownership TXT instructions",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [
+      ORG_UUID_ARG,
+      { name: "domain", description: "Domain to register, e.g. example.com", required: true }
+    ],
+    examples: [
+      `yarn gr ${path.join(" ")} --org-uuid $ORG_UUID --domain example.com --allow-write`
+    ],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.registerOrgDomain(
+        requireOrgId(hctx.args),
+        requireDomain(hctx.args)
+      );
+      outputSingle(result, hctx.ctx, ORG_DOMAIN_COLUMNS);
+    }
+  };
+}
+var domainCommands = [
+  {
+    path: ["org", "domains", "list"],
+    description: "List domains registered to an organization",
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG],
+    examples: ["yarn gr org domains list --org-uuid $ORG_UUID"],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.listOrgDomains(
+        requireOrgId(hctx.args)
+      );
+      outputData(result, hctx.ctx, ORG_DOMAIN_COLUMNS);
+    }
+  },
+  {
+    path: ["org", "domains", "get"],
+    description: "Get a registered organization domain",
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: ["yarn gr org domains get --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID"],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.getOrgDomain(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx, ORG_DOMAIN_COLUMNS);
+    }
+  },
+  registerDomainCommand(["org", "domains", "register"]),
+  registerDomainCommand(["org", "domains", "create"]),
+  {
+    path: ["org", "domains", "verify-ownership"],
+    description: "Verify domain ownership by checking the _gravity-verify TXT record",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: [
+      "yarn gr org domains verify-ownership --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --allow-write"
+    ],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.verifyOrgDomainOwnership(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  },
+  {
+    path: ["org", "domains", "delete"],
+    description: "Delete a registered organization domain",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: [
+      "yarn gr org domains delete --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --allow-write"
+    ],
+    handler: async (hctx) => {
+      const domainUuid = requireDomainUuid(hctx.args);
+      await requireAuth(hctx.ctx).apiClient.deleteOrgDomain(requireOrgId(hctx.args), domainUuid);
+      process.stdout.write(`Deleted org domain ${domainUuid}
+`);
+    }
+  },
+  {
+    path: ["org", "domains", "email", "enable"],
+    description: "Enable email DNS records on a verified organization domain",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: [
+      "yarn gr org domains email enable --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --allow-write"
+    ],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.enableOrgDomainEmail(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  },
+  {
+    path: ["org", "domains", "email", "get"],
+    description: "Get email DNS setup and status for an organization domain",
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: ["yarn gr org domains email get --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID"],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.getOrgDomainEmail(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  },
+  emailVerifyCommand(
+    ["org", "domains", "email", "verify"],
+    "Verify email DNS records, including MX"
+  ),
+  emailVerifyCommand(
+    ["org", "domains", "email", "verify-mx"],
+    "Verify email DNS records, including MX"
+  ),
+  {
+    path: ["org", "domains", "email", "disable"],
+    description: "Disable email on an organization domain",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [
+      ORG_UUID_ARG,
+      DOMAIN_UUID_ARG,
+      {
+        name: "confirm",
+        description: "Confirm removal of inbox routing that depends on this domain",
+        isFlag: true
+      }
+    ],
+    examples: [
+      "yarn gr org domains email disable --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --confirm --allow-write"
+    ],
+    handler: async (hctx) => {
+      const domainUuid = requireDomainUuid(hctx.args);
+      const result = await requireAuth(hctx.ctx).apiClient.disableOrgDomainEmail(
+        requireOrgId(hctx.args),
+        domainUuid,
+        hctx.args.confirm === true
+      );
+      if (!result.ok) {
+        const { inboxCount } = result.impact;
+        throw new CLIError(
+          `Email is still used by ${inboxCount} ${pluralize(
+            inboxCount,
+            "inbox",
+            "inboxes"
+          )}. Re-run with --confirm to disable it anyway.`
+        );
+      }
+      process.stdout.write(`Disabled email for org domain ${domainUuid}
+`);
+    }
+  },
+  {
+    path: ["org", "domains", "site", "enable"],
+    description: "Enable custom site CNAME verification on a verified organization domain",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: [
+      "yarn gr org domains site enable --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --allow-write"
+    ],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.enableOrgDomainSite(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  },
+  {
+    path: ["org", "domains", "site", "get"],
+    description: "Get custom site CNAME setup and status for an organization domain",
+    requiresWorkspace: false,
+    args: [ORG_UUID_ARG, DOMAIN_UUID_ARG],
+    examples: ["yarn gr org domains site get --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID"],
+    handler: async (hctx) => {
+      const result = await requireAuth(hctx.ctx).apiClient.getOrgDomainSite(
+        requireOrgId(hctx.args),
+        requireDomainUuid(hctx.args)
+      );
+      outputSingle(result, hctx.ctx);
+    }
+  },
+  siteVerifyCommand(
+    ["org", "domains", "site", "verify"],
+    "Verify the site CNAME points at Gravity Rail"
+  ),
+  siteVerifyCommand(
+    ["org", "domains", "site", "verify-cname"],
+    "Verify the site CNAME points at Gravity Rail"
+  ),
+  {
+    path: ["org", "domains", "site", "disable"],
+    description: "Disable custom site routing on an organization domain",
+    mutates: true,
+    requiresWorkspace: false,
+    args: [
+      ORG_UUID_ARG,
+      DOMAIN_UUID_ARG,
+      {
+        name: "confirm",
+        description: "Confirm removal of site mappings that depend on this domain",
+        isFlag: true
+      }
+    ],
+    examples: [
+      "yarn gr org domains site disable --org-uuid $ORG_UUID --domain-uuid $DOMAIN_UUID --confirm --allow-write"
+    ],
+    handler: async (hctx) => {
+      const domainUuid = requireDomainUuid(hctx.args);
+      const result = await requireAuth(hctx.ctx).apiClient.disableOrgDomainSite(
+        requireOrgId(hctx.args),
+        domainUuid,
+        hctx.args.confirm === true
+      );
+      if (!result.ok) {
+        const { siteCount } = result.impact;
+        throw new CLIError(
+          `Site routing is still used by ${siteCount} ${pluralize(
+            siteCount,
+            "site"
+          )}. Re-run with --confirm to disable it anyway.`
+        );
+      }
+      process.stdout.write(`Disabled site routing for org domain ${domainUuid}
+`);
+    }
+  }
 ];
 var orgDomain = {
   name: "org",
-  description: "Organization membership",
+  description: "Organization membership and domains",
   commands: [
     {
       path: ["org", "list"],
@@ -6237,7 +8074,8 @@ var orgDomain = {
         const result = await requireAuth(ctx).apiClient.getMyOrganizations();
         outputData(result, ctx, ORG_COLUMNS);
       }
-    }
+    },
+    ...domainCommands
   ]
 };